0001 # THIS FILE IS AUTOMATICALLY GENERATED. EDIT THE SOURCE FILE NOT THIS ONE 0002 0003 """Various descriptions of data specific to LG VI125""" 0004 0005 import re 0006 0007 from prototypes import * 0008 from prototypeslg import * 0009 0010 # Make all lg stuff available in this module as well 0011 from p_lg import * 0012 0013 0014 # We use LSB for all integer like fields 0015 UINT=UINTlsb 0016 BOOL=BOOLlsb 0017 0018 NUMSPEEDDIALS=100 0019 FIRSTSPEEDDIAL=1 0020 LASTSPEEDDIAL=99 0021 NUMPHONEBOOKENTRIES=200 0022 MAXCALENDARDESCRIPTION=38 0023 0024 NUMEMAILS=3 0025 NUMPHONENUMBERS=5 0026 0027 NUMGROUPS=20 0028 NUMMAPGROUPS=500 0029 0030 NORINGTONE=0 0031 NOMSGRINGTONE=0 0032 NOWALLPAPER=0 0033 0034 MEMOLENGTH=33 0035 SMS_CANNED_MAX_ITEMS=18 0036 SMS_CANNED_MAX_LENGTH=101 0037 SMS_CANNED_FILENAME="sms/mediacan000.dat" 0038 SMS_PATTERNS={'Inbox': re.compile(r"^.*/inbox[0-9][0-9][0-9]\.dat$"), 0039 'Sent': re.compile(r"^.*/outbox[0-9][0-9][0-9]\.dat$"), 0040 'Saved': re.compile(r"^.*/sf[0-9][0-9]\.dat$"), 0041 } 0042 0043 0044 0045 numbertypetab=( 'cell', 'home', 'office', 'fax', 'pager' ) 0046 0047 0048 # Calendar parameters 0049 NUMCALENDARENTRIES=300 # ?? for VI125 0050 CAL_REP_NONE=0x10 0051 CAL_REP_DAILY=0x11 0052 CAL_REP_MONFRI=0x12 0053 CAL_REP_WEEKLY=0x13 0054 CAL_REP_MONTHLY=0x14 0055 CAL_REP_YEARLY=0x15 0056 CAL_DOW_SUN=0x0800 0057 CAL_DOW_MON=0x0400 0058 CAL_DOW_TUE=0x0200 0059 CAL_DOW_WED=0x0100 0060 CAL_DOW_THU=0x0080 0061 CAL_DOW_FRI=0x0040 0062 CAL_DOW_SAT=0x0020 0063 CAL_DOW_EXCEPTIONS=0x0010 0064 CAL_REMINDER_NONE=0 0065 CAL_REMINDER_ONTIME=1 0066 CAL_REMINDER_5MIN=2 0067 CAL_REMINDER_10MIN=3 0068 CAL_REMINDER_1HOUR=4 0069 CAL_REMINDER_1DAY=5 0070 CAL_REMINDER_2DAYS=6 0071 CAL_REPEAT_DATE=(4095, 12, 31) 0072 0073 cal_dir='sch' 0074 cal_data_file_name='sch/schedule.dat' 0075 cal_exception_file_name='sch/schexception.dat' 0076 cal_has_voice_id=False 0077 0078 class firmwareresponse(BaseProtogenClass): 0079 __fields=['command', 'date1', 'time1', 'date2', 'time2', 'firmwareversion'] 0080 0081 def __init__(self, *args, **kwargs): 0082 dict={} 0083 # What was supplied to this function 0084 dict.update(kwargs) 0085 # Parent constructor 0086 super(firmwareresponse,self).__init__(**dict) 0087 if self.__class__ is firmwareresponse: 0088 self._update(args,dict) 0089 0090 0091 def getfields(self): 0092 return self.__fields 0093 0094 0095 def _update(self, args, kwargs): 0096 super(firmwareresponse,self)._update(args,kwargs) 0097 keys=kwargs.keys() 0098 for key in keys: 0099 if key in self.__fields: 0100 setattr(self, key, kwargs[key]) 0101 del kwargs[key] 0102 # Were any unrecognized kwargs passed in? 0103 if __debug__: 0104 self._complainaboutunusedargs(firmwareresponse,kwargs) 0105 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0106 # Make all P fields that haven't already been constructed 0107 0108 0109 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0110 'Writes this packet to the supplied buffer' 0111 self._bufferstartoffset=buf.getcurrentoffset() 0112 self.__field_command.writetobuffer(buf) 0113 self.__field_date1.writetobuffer(buf) 0114 self.__field_time1.writetobuffer(buf) 0115 self.__field_date2.writetobuffer(buf) 0116 self.__field_time2.writetobuffer(buf) 0117 self.__field_firmwareversion.writetobuffer(buf) 0118 self._bufferendoffset=buf.getcurrentoffset() 0119 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0120 0121 0122 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0123 'Reads this packet from the supplied buffer' 0124 self._bufferstartoffset=buf.getcurrentoffset() 0125 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0126 self.__field_command=UINT(**{'sizeinbytes': 1}) 0127 self.__field_command.readfrombuffer(buf) 0128 self.__field_date1=USTRING(**{'sizeinbytes': 11, 'terminator': None}) 0129 self.__field_date1.readfrombuffer(buf) 0130 self.__field_time1=USTRING(**{'sizeinbytes': 8, 'terminator': None}) 0131 self.__field_time1.readfrombuffer(buf) 0132 self.__field_date2=USTRING(**{'sizeinbytes': 11, 'terminator': None}) 0133 self.__field_date2.readfrombuffer(buf) 0134 self.__field_time2=USTRING(**{'sizeinbytes': 8, 'terminator': None}) 0135 self.__field_time2.readfrombuffer(buf) 0136 self.__field_firmwareversion=USTRING(**{'sizeinbytes': 8, 'terminator': None}) 0137 self.__field_firmwareversion.readfrombuffer(buf) 0138 self._bufferendoffset=buf.getcurrentoffset() 0139 0140 0141 def __getfield_command(self): 0142 return self.__field_command.getvalue() 0143 0144 def __setfield_command(self, value): 0145 if isinstance(value,UINT): 0146 self.__field_command=value 0147 else: 0148 self.__field_command=UINT(value,**{'sizeinbytes': 1}) 0149 0150 def __delfield_command(self): del self.__field_command 0151 0152 command=property(__getfield_command, __setfield_command, __delfield_command, None) 0153 0154 def __getfield_date1(self): 0155 return self.__field_date1.getvalue() 0156 0157 def __setfield_date1(self, value): 0158 if isinstance(value,USTRING): 0159 self.__field_date1=value 0160 else: 0161 self.__field_date1=USTRING(value,**{'sizeinbytes': 11, 'terminator': None}) 0162 0163 def __delfield_date1(self): del self.__field_date1 0164 0165 date1=property(__getfield_date1, __setfield_date1, __delfield_date1, None) 0166 0167 def __getfield_time1(self): 0168 return self.__field_time1.getvalue() 0169 0170 def __setfield_time1(self, value): 0171 if isinstance(value,USTRING): 0172 self.__field_time1=value 0173 else: 0174 self.__field_time1=USTRING(value,**{'sizeinbytes': 8, 'terminator': None}) 0175 0176 def __delfield_time1(self): del self.__field_time1 0177 0178 time1=property(__getfield_time1, __setfield_time1, __delfield_time1, None) 0179 0180 def __getfield_date2(self): 0181 return self.__field_date2.getvalue() 0182 0183 def __setfield_date2(self, value): 0184 if isinstance(value,USTRING): 0185 self.__field_date2=value 0186 else: 0187 self.__field_date2=USTRING(value,**{'sizeinbytes': 11, 'terminator': None}) 0188 0189 def __delfield_date2(self): del self.__field_date2 0190 0191 date2=property(__getfield_date2, __setfield_date2, __delfield_date2, None) 0192 0193 def __getfield_time2(self): 0194 return self.__field_time2.getvalue() 0195 0196 def __setfield_time2(self, value): 0197 if isinstance(value,USTRING): 0198 self.__field_time2=value 0199 else: 0200 self.__field_time2=USTRING(value,**{'sizeinbytes': 8, 'terminator': None}) 0201 0202 def __delfield_time2(self): del self.__field_time2 0203 0204 time2=property(__getfield_time2, __setfield_time2, __delfield_time2, None) 0205 0206 def __getfield_firmwareversion(self): 0207 return self.__field_firmwareversion.getvalue() 0208 0209 def __setfield_firmwareversion(self, value): 0210 if isinstance(value,USTRING): 0211 self.__field_firmwareversion=value 0212 else: 0213 self.__field_firmwareversion=USTRING(value,**{'sizeinbytes': 8, 'terminator': None}) 0214 0215 def __delfield_firmwareversion(self): del self.__field_firmwareversion 0216 0217 firmwareversion=property(__getfield_firmwareversion, __setfield_firmwareversion, __delfield_firmwareversion, None) 0218 0219 def iscontainer(self): 0220 return True 0221 0222 def containerelements(self): 0223 yield ('command', self.__field_command, None) 0224 yield ('date1', self.__field_date1, None) 0225 yield ('time1', self.__field_time1, None) 0226 yield ('date2', self.__field_date2, None) 0227 yield ('time2', self.__field_time2, None) 0228 yield ('firmwareversion', self.__field_firmwareversion, None) 0229 0230 0231 0232 0233 class pbreadentryresponse(BaseProtogenClass): 0234 "Results of reading one entry" 0235 __fields=['header', 'entry'] 0236 0237 def __init__(self, *args, **kwargs): 0238 dict={} 0239 # What was supplied to this function 0240 dict.update(kwargs) 0241 # Parent constructor 0242 super(pbreadentryresponse,self).__init__(**dict) 0243 if self.__class__ is pbreadentryresponse: 0244 self._update(args,dict) 0245 0246 0247 def getfields(self): 0248 return self.__fields 0249 0250 0251 def _update(self, args, kwargs): 0252 super(pbreadentryresponse,self)._update(args,kwargs) 0253 keys=kwargs.keys() 0254 for key in keys: 0255 if key in self.__fields: 0256 setattr(self, key, kwargs[key]) 0257 del kwargs[key] 0258 # Were any unrecognized kwargs passed in? 0259 if __debug__: 0260 self._complainaboutunusedargs(pbreadentryresponse,kwargs) 0261 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0262 # Make all P fields that haven't already been constructed 0263 0264 0265 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0266 'Writes this packet to the supplied buffer' 0267 self._bufferstartoffset=buf.getcurrentoffset() 0268 self.__field_header.writetobuffer(buf) 0269 self.__field_entry.writetobuffer(buf) 0270 self._bufferendoffset=buf.getcurrentoffset() 0271 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0272 0273 0274 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0275 'Reads this packet from the supplied buffer' 0276 self._bufferstartoffset=buf.getcurrentoffset() 0277 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0278 self.__field_header=pbheader() 0279 self.__field_header.readfrombuffer(buf) 0280 self.__field_entry=pbentry() 0281 self.__field_entry.readfrombuffer(buf) 0282 self._bufferendoffset=buf.getcurrentoffset() 0283 0284 0285 def __getfield_header(self): 0286 return self.__field_header.getvalue() 0287 0288 def __setfield_header(self, value): 0289 if isinstance(value,pbheader): 0290 self.__field_header=value 0291 else: 0292 self.__field_header=pbheader(value,) 0293 0294 def __delfield_header(self): del self.__field_header 0295 0296 header=property(__getfield_header, __setfield_header, __delfield_header, None) 0297 0298 def __getfield_entry(self): 0299 return self.__field_entry.getvalue() 0300 0301 def __setfield_entry(self, value): 0302 if isinstance(value,pbentry): 0303 self.__field_entry=value 0304 else: 0305 self.__field_entry=pbentry(value,) 0306 0307 def __delfield_entry(self): del self.__field_entry 0308 0309 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 0310 0311 def iscontainer(self): 0312 return True 0313 0314 def containerelements(self): 0315 yield ('header', self.__field_header, None) 0316 yield ('entry', self.__field_entry, None) 0317 0318 0319 0320 0321 class pbupdateentryrequest(BaseProtogenClass): 0322 __fields=['header', 'entry'] 0323 0324 def __init__(self, *args, **kwargs): 0325 dict={} 0326 # What was supplied to this function 0327 dict.update(kwargs) 0328 # Parent constructor 0329 super(pbupdateentryrequest,self).__init__(**dict) 0330 if self.__class__ is pbupdateentryrequest: 0331 self._update(args,dict) 0332 0333 0334 def getfields(self): 0335 return self.__fields 0336 0337 0338 def _update(self, args, kwargs): 0339 super(pbupdateentryrequest,self)._update(args,kwargs) 0340 keys=kwargs.keys() 0341 for key in keys: 0342 if key in self.__fields: 0343 setattr(self, key, kwargs[key]) 0344 del kwargs[key] 0345 # Were any unrecognized kwargs passed in? 0346 if __debug__: 0347 self._complainaboutunusedargs(pbupdateentryrequest,kwargs) 0348 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0349 # Make all P fields that haven't already been constructed 0350 0351 0352 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0353 'Writes this packet to the supplied buffer' 0354 self._bufferstartoffset=buf.getcurrentoffset() 0355 try: self.__field_header 0356 except: 0357 self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01}) 0358 self.__field_header.writetobuffer(buf) 0359 self.__field_entry.writetobuffer(buf) 0360 self._bufferendoffset=buf.getcurrentoffset() 0361 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0362 0363 0364 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0365 'Reads this packet from the supplied buffer' 0366 self._bufferstartoffset=buf.getcurrentoffset() 0367 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0368 self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01}) 0369 self.__field_header.readfrombuffer(buf) 0370 self.__field_entry=pbentry() 0371 self.__field_entry.readfrombuffer(buf) 0372 self._bufferendoffset=buf.getcurrentoffset() 0373 0374 0375 def __getfield_header(self): 0376 try: self.__field_header 0377 except: 0378 self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01}) 0379 return self.__field_header.getvalue() 0380 0381 def __setfield_header(self, value): 0382 if isinstance(value,pbheader): 0383 self.__field_header=value 0384 else: 0385 self.__field_header=pbheader(value,**{'command': 0x04, 'flag': 0x01}) 0386 0387 def __delfield_header(self): del self.__field_header 0388 0389 header=property(__getfield_header, __setfield_header, __delfield_header, None) 0390 0391 def __getfield_entry(self): 0392 return self.__field_entry.getvalue() 0393 0394 def __setfield_entry(self, value): 0395 if isinstance(value,pbentry): 0396 self.__field_entry=value 0397 else: 0398 self.__field_entry=pbentry(value,) 0399 0400 def __delfield_entry(self): del self.__field_entry 0401 0402 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 0403 0404 def iscontainer(self): 0405 return True 0406 0407 def containerelements(self): 0408 yield ('header', self.__field_header, None) 0409 yield ('entry', self.__field_entry, None) 0410 0411 0412 0413 0414 class pbappendentryrequest(BaseProtogenClass): 0415 __fields=['header', 'entry'] 0416 0417 def __init__(self, *args, **kwargs): 0418 dict={} 0419 # What was supplied to this function 0420 dict.update(kwargs) 0421 # Parent constructor 0422 super(pbappendentryrequest,self).__init__(**dict) 0423 if self.__class__ is pbappendentryrequest: 0424 self._update(args,dict) 0425 0426 0427 def getfields(self): 0428 return self.__fields 0429 0430 0431 def _update(self, args, kwargs): 0432 super(pbappendentryrequest,self)._update(args,kwargs) 0433 keys=kwargs.keys() 0434 for key in keys: 0435 if key in self.__fields: 0436 setattr(self, key, kwargs[key]) 0437 del kwargs[key] 0438 # Were any unrecognized kwargs passed in? 0439 if __debug__: 0440 self._complainaboutunusedargs(pbappendentryrequest,kwargs) 0441 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0442 # Make all P fields that haven't already been constructed 0443 0444 0445 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0446 'Writes this packet to the supplied buffer' 0447 self._bufferstartoffset=buf.getcurrentoffset() 0448 try: self.__field_header 0449 except: 0450 self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01}) 0451 self.__field_header.writetobuffer(buf) 0452 self.__field_entry.writetobuffer(buf) 0453 self._bufferendoffset=buf.getcurrentoffset() 0454 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0455 0456 0457 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0458 'Reads this packet from the supplied buffer' 0459 self._bufferstartoffset=buf.getcurrentoffset() 0460 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0461 self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01}) 0462 self.__field_header.readfrombuffer(buf) 0463 self.__field_entry=pbentry() 0464 self.__field_entry.readfrombuffer(buf) 0465 self._bufferendoffset=buf.getcurrentoffset() 0466 0467 0468 def __getfield_header(self): 0469 try: self.__field_header 0470 except: 0471 self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01}) 0472 return self.__field_header.getvalue() 0473 0474 def __setfield_header(self, value): 0475 if isinstance(value,pbheader): 0476 self.__field_header=value 0477 else: 0478 self.__field_header=pbheader(value,**{'command': 0x03, 'flag': 0x01}) 0479 0480 def __delfield_header(self): del self.__field_header 0481 0482 header=property(__getfield_header, __setfield_header, __delfield_header, None) 0483 0484 def __getfield_entry(self): 0485 return self.__field_entry.getvalue() 0486 0487 def __setfield_entry(self, value): 0488 if isinstance(value,pbentry): 0489 self.__field_entry=value 0490 else: 0491 self.__field_entry=pbentry(value,) 0492 0493 def __delfield_entry(self): del self.__field_entry 0494 0495 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 0496 0497 def iscontainer(self): 0498 return True 0499 0500 def containerelements(self): 0501 yield ('header', self.__field_header, None) 0502 yield ('entry', self.__field_entry, None) 0503 0504 0505 0506 0507 class pbentry(BaseProtogenClass): 0508 __fields=['serial1', 'unknown3', 'unknown4', 'unknown5', 'unknown6', 'unknown7', 'serial2', 'unknown8', 'unknown9', 'unknown10', 'name', 'group', 'unknown11', 'ringtone', 'unknown12', 'unknown13', 'memo', 'emails', 'url', 'avatar', 'numberspeeddials', 'numbertypes', 'numbers', 'unknown14'] 0509 0510 def __init__(self, *args, **kwargs): 0511 dict={} 0512 # What was supplied to this function 0513 dict.update(kwargs) 0514 # Parent constructor 0515 super(pbentry,self).__init__(**dict) 0516 if self.__class__ is pbentry: 0517 self._update(args,dict) 0518 0519 0520 def getfields(self): 0521 return self.__fields 0522 0523 0524 def _update(self, args, kwargs): 0525 super(pbentry,self)._update(args,kwargs) 0526 keys=kwargs.keys() 0527 for key in keys: 0528 if key in self.__fields: 0529 setattr(self, key, kwargs[key]) 0530 del kwargs[key] 0531 # Were any unrecognized kwargs passed in? 0532 if __debug__: 0533 self._complainaboutunusedargs(pbentry,kwargs) 0534 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0535 # Make all P fields that haven't already been constructed 0536 0537 0538 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0539 'Writes this packet to the supplied buffer' 0540 self._bufferstartoffset=buf.getcurrentoffset() 0541 self.__field_serial1.writetobuffer(buf) 0542 try: self.__field_unknown3 0543 except: 0544 self.__field_unknown3=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 0545 self.__field_unknown3.writetobuffer(buf) 0546 try: self.__field_unknown4 0547 except: 0548 self.__field_unknown4=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 0549 self.__field_unknown4.writetobuffer(buf) 0550 try: self.__field_unknown5 0551 except: 0552 self.__field_unknown5=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 0553 self.__field_unknown5.writetobuffer(buf) 0554 try: self.__field_unknown6 0555 except: 0556 self.__field_unknown6=UINT(**{'sizeinbytes': 1, 'constant': 0x72}) 0557 self.__field_unknown6.writetobuffer(buf) 0558 self.__field_unknown7.writetobuffer(buf) 0559 self.__field_serial2.writetobuffer(buf) 0560 try: self.__field_unknown8 0561 except: 0562 self.__field_unknown8=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 0563 self.__field_unknown8.writetobuffer(buf) 0564 try: self.__field_unknown9 0565 except: 0566 self.__field_unknown9=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 0567 self.__field_unknown9.writetobuffer(buf) 0568 try: self.__field_unknown10 0569 except: 0570 self.__field_unknown10=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 0571 self.__field_unknown10.writetobuffer(buf) 0572 self.__field_name.writetobuffer(buf) 0573 self.__field_group.writetobuffer(buf) 0574 try: self.__field_unknown11 0575 except: 0576 self.__field_unknown11=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 0577 self.__field_unknown11.writetobuffer(buf) 0578 self.__field_ringtone.writetobuffer(buf) 0579 self.__field_unknown12.writetobuffer(buf) 0580 try: self.__field_unknown13 0581 except: 0582 self.__field_unknown13=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 0583 self.__field_unknown13.writetobuffer(buf) 0584 self.__field_memo.writetobuffer(buf) 0585 try: self.__field_emails 0586 except: 0587 self.__field_emails=LIST(**{'elementclass': _gen_p_lgvi125_134, 'length': NUMEMAILS}) 0588 self.__field_emails.writetobuffer(buf) 0589 self.__field_url.writetobuffer(buf) 0590 self.__field_avatar.writetobuffer(buf) 0591 try: self.__field_numberspeeddials 0592 except: 0593 self.__field_numberspeeddials=LIST(**{'elementclass': _gen_p_lgvi125_138, 'length': NUMPHONENUMBERS}) 0594 self.__field_numberspeeddials.writetobuffer(buf) 0595 try: self.__field_numbertypes 0596 except: 0597 self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lgvi125_140, 'length': NUMPHONENUMBERS}) 0598 self.__field_numbertypes.writetobuffer(buf) 0599 try: self.__field_numbers 0600 except: 0601 self.__field_numbers=LIST(**{'elementclass': _gen_p_lgvi125_142, 'length': NUMPHONENUMBERS}) 0602 self.__field_numbers.writetobuffer(buf) 0603 try: self.__field_unknown14 0604 except: 0605 self.__field_unknown14=UINT(**{'sizeinbytes': 1, 'constant': 0x7c}) 0606 self.__field_unknown14.writetobuffer(buf) 0607 self._bufferendoffset=buf.getcurrentoffset() 0608 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0609 0610 0611 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0612 'Reads this packet from the supplied buffer' 0613 self._bufferstartoffset=buf.getcurrentoffset() 0614 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0615 self.__field_serial1=UINT(**{'sizeinbytes': 1}) 0616 self.__field_serial1.readfrombuffer(buf) 0617 self.__field_unknown3=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 0618 self.__field_unknown3.readfrombuffer(buf) 0619 self.__field_unknown4=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 0620 self.__field_unknown4.readfrombuffer(buf) 0621 self.__field_unknown5=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 0622 self.__field_unknown5.readfrombuffer(buf) 0623 self.__field_unknown6=UINT(**{'sizeinbytes': 1, 'constant': 0x72}) 0624 self.__field_unknown6.readfrombuffer(buf) 0625 self.__field_unknown7=UINT(**{'sizeinbytes': 1}) 0626 self.__field_unknown7.readfrombuffer(buf) 0627 self.__field_serial2=UINT(**{'sizeinbytes': 1}) 0628 self.__field_serial2.readfrombuffer(buf) 0629 self.__field_unknown8=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 0630 self.__field_unknown8.readfrombuffer(buf) 0631 self.__field_unknown9=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 0632 self.__field_unknown9.readfrombuffer(buf) 0633 self.__field_unknown10=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 0634 self.__field_unknown10.readfrombuffer(buf) 0635 self.__field_name=USTRING(**{'sizeinbytes': 33, 'raiseonunterminatedread': False}) 0636 self.__field_name.readfrombuffer(buf) 0637 self.__field_group=UINT(**{'sizeinbytes': 1}) 0638 self.__field_group.readfrombuffer(buf) 0639 self.__field_unknown11=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 0640 self.__field_unknown11.readfrombuffer(buf) 0641 self.__field_ringtone=UINT(**{'sizeinbytes': 1}) 0642 self.__field_ringtone.readfrombuffer(buf) 0643 self.__field_unknown12=UINT(**{'sizeinbytes': 1}) 0644 self.__field_unknown12.readfrombuffer(buf) 0645 self.__field_unknown13=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 0646 self.__field_unknown13.readfrombuffer(buf) 0647 self.__field_memo=USTRING(**{'raiseonunterminatedread': False, 'sizeinbytes': MEMOLENGTH}) 0648 self.__field_memo.readfrombuffer(buf) 0649 self.__field_emails=LIST(**{'elementclass': _gen_p_lgvi125_134, 'length': NUMEMAILS}) 0650 self.__field_emails.readfrombuffer(buf) 0651 self.__field_url=USTRING(**{'sizeinbytes': 73, 'raiseonunterminatedread': False}) 0652 self.__field_url.readfrombuffer(buf) 0653 self.__field_avatar=UINT(**{'sizeinbytes': 4}) 0654 self.__field_avatar.readfrombuffer(buf) 0655 self.__field_numberspeeddials=LIST(**{'elementclass': _gen_p_lgvi125_138, 'length': NUMPHONENUMBERS}) 0656 self.__field_numberspeeddials.readfrombuffer(buf) 0657 self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lgvi125_140, 'length': NUMPHONENUMBERS}) 0658 self.__field_numbertypes.readfrombuffer(buf) 0659 self.__field_numbers=LIST(**{'elementclass': _gen_p_lgvi125_142, 'length': NUMPHONENUMBERS}) 0660 self.__field_numbers.readfrombuffer(buf) 0661 self.__field_unknown14=UINT(**{'sizeinbytes': 1, 'constant': 0x7c}) 0662 self.__field_unknown14.readfrombuffer(buf) 0663 self._bufferendoffset=buf.getcurrentoffset() 0664 0665 0666 def __getfield_serial1(self): 0667 return self.__field_serial1.getvalue() 0668 0669 def __setfield_serial1(self, value): 0670 if isinstance(value,UINT): 0671 self.__field_serial1=value 0672 else: 0673 self.__field_serial1=UINT(value,**{'sizeinbytes': 1}) 0674 0675 def __delfield_serial1(self): del self.__field_serial1 0676 0677 serial1=property(__getfield_serial1, __setfield_serial1, __delfield_serial1, None) 0678 0679 def __getfield_unknown3(self): 0680 try: self.__field_unknown3 0681 except: 0682 self.__field_unknown3=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 0683 return self.__field_unknown3.getvalue() 0684 0685 def __setfield_unknown3(self, value): 0686 if isinstance(value,UINT): 0687 self.__field_unknown3=value 0688 else: 0689 self.__field_unknown3=UINT(value,**{'sizeinbytes': 1, 'constant': 0x00}) 0690 0691 def __delfield_unknown3(self): del self.__field_unknown3 0692 0693 unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None) 0694 0695 def __getfield_unknown4(self): 0696 try: self.__field_unknown4 0697 except: 0698 self.__field_unknown4=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 0699 return self.__field_unknown4.getvalue() 0700 0701 def __setfield_unknown4(self, value): 0702 if isinstance(value,UINT): 0703 self.__field_unknown4=value 0704 else: 0705 self.__field_unknown4=UINT(value,**{'sizeinbytes': 1, 'constant': 0x00}) 0706 0707 def __delfield_unknown4(self): del self.__field_unknown4 0708 0709 unknown4=property(__getfield_unknown4, __setfield_unknown4, __delfield_unknown4, None) 0710 0711 def __getfield_unknown5(self): 0712 try: self.__field_unknown5 0713 except: 0714 self.__field_unknown5=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 0715 return self.__field_unknown5.getvalue() 0716 0717 def __setfield_unknown5(self, value): 0718 if isinstance(value,UINT): 0719 self.__field_unknown5=value 0720 else: 0721 self.__field_unknown5=UINT(value,**{'sizeinbytes': 1, 'constant': 0x00}) 0722 0723 def __delfield_unknown5(self): del self.__field_unknown5 0724 0725 unknown5=property(__getfield_unknown5, __setfield_unknown5, __delfield_unknown5, None) 0726 0727 def __getfield_unknown6(self): 0728 try: self.__field_unknown6 0729 except: 0730 self.__field_unknown6=UINT(**{'sizeinbytes': 1, 'constant': 0x72}) 0731 return self.__field_unknown6.getvalue() 0732 0733 def __setfield_unknown6(self, value): 0734 if isinstance(value,UINT): 0735 self.__field_unknown6=value 0736 else: 0737 self.__field_unknown6=UINT(value,**{'sizeinbytes': 1, 'constant': 0x72}) 0738 0739 def __delfield_unknown6(self): del self.__field_unknown6 0740 0741 unknown6=property(__getfield_unknown6, __setfield_unknown6, __delfield_unknown6, None) 0742 0743 def __getfield_unknown7(self): 0744 return self.__field_unknown7.getvalue() 0745 0746 def __setfield_unknown7(self, value): 0747 if isinstance(value,UINT): 0748 self.__field_unknown7=value 0749 else: 0750 self.__field_unknown7=UINT(value,**{'sizeinbytes': 1}) 0751 0752 def __delfield_unknown7(self): del self.__field_unknown7 0753 0754 unknown7=property(__getfield_unknown7, __setfield_unknown7, __delfield_unknown7, None) 0755 0756 def __getfield_serial2(self): 0757 return self.__field_serial2.getvalue() 0758 0759 def __setfield_serial2(self, value): 0760 if isinstance(value,UINT): 0761 self.__field_serial2=value 0762 else: 0763 self.__field_serial2=UINT(value,**{'sizeinbytes': 1}) 0764 0765 def __delfield_serial2(self): del self.__field_serial2 0766 0767 serial2=property(__getfield_serial2, __setfield_serial2, __delfield_serial2, None) 0768 0769 def __getfield_unknown8(self): 0770 try: self.__field_unknown8 0771 except: 0772 self.__field_unknown8=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 0773 return self.__field_unknown8.getvalue() 0774 0775 def __setfield_unknown8(self, value): 0776 if isinstance(value,UINT): 0777 self.__field_unknown8=value 0778 else: 0779 self.__field_unknown8=UINT(value,**{'sizeinbytes': 1, 'constant': 0x00}) 0780 0781 def __delfield_unknown8(self): del self.__field_unknown8 0782 0783 unknown8=property(__getfield_unknown8, __setfield_unknown8, __delfield_unknown8, None) 0784 0785 def __getfield_unknown9(self): 0786 try: self.__field_unknown9 0787 except: 0788 self.__field_unknown9=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 0789 return self.__field_unknown9.getvalue() 0790 0791 def __setfield_unknown9(self, value): 0792 if isinstance(value,UINT): 0793 self.__field_unknown9=value 0794 else: 0795 self.__field_unknown9=UINT(value,**{'sizeinbytes': 1, 'constant': 0x00}) 0796 0797 def __delfield_unknown9(self): del self.__field_unknown9 0798 0799 unknown9=property(__getfield_unknown9, __setfield_unknown9, __delfield_unknown9, None) 0800 0801 def __getfield_unknown10(self): 0802 try: self.__field_unknown10 0803 except: 0804 self.__field_unknown10=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 0805 return self.__field_unknown10.getvalue() 0806 0807 def __setfield_unknown10(self, value): 0808 if isinstance(value,UINT): 0809 self.__field_unknown10=value 0810 else: 0811 self.__field_unknown10=UINT(value,**{'sizeinbytes': 1, 'constant': 0x00}) 0812 0813 def __delfield_unknown10(self): del self.__field_unknown10 0814 0815 unknown10=property(__getfield_unknown10, __setfield_unknown10, __delfield_unknown10, None) 0816 0817 def __getfield_name(self): 0818 return self.__field_name.getvalue() 0819 0820 def __setfield_name(self, value): 0821 if isinstance(value,USTRING): 0822 self.__field_name=value 0823 else: 0824 self.__field_name=USTRING(value,**{'sizeinbytes': 33, 'raiseonunterminatedread': False}) 0825 0826 def __delfield_name(self): del self.__field_name 0827 0828 name=property(__getfield_name, __setfield_name, __delfield_name, None) 0829 0830 def __getfield_group(self): 0831 return self.__field_group.getvalue() 0832 0833 def __setfield_group(self, value): 0834 if isinstance(value,UINT): 0835 self.__field_group=value 0836 else: 0837 self.__field_group=UINT(value,**{'sizeinbytes': 1}) 0838 0839 def __delfield_group(self): del self.__field_group 0840 0841 group=property(__getfield_group, __setfield_group, __delfield_group, None) 0842 0843 def __getfield_unknown11(self): 0844 try: self.__field_unknown11 0845 except: 0846 self.__field_unknown11=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 0847 return self.__field_unknown11.getvalue() 0848 0849 def __setfield_unknown11(self, value): 0850 if isinstance(value,UINT): 0851 self.__field_unknown11=value 0852 else: 0853 self.__field_unknown11=UINT(value,**{'sizeinbytes': 1, 'constant': 0x00}) 0854 0855 def __delfield_unknown11(self): del self.__field_unknown11 0856 0857 unknown11=property(__getfield_unknown11, __setfield_unknown11, __delfield_unknown11, None) 0858 0859 def __getfield_ringtone(self): 0860 return self.__field_ringtone.getvalue() 0861 0862 def __setfield_ringtone(self, value): 0863 if isinstance(value,UINT): 0864 self.__field_ringtone=value 0865 else: 0866 self.__field_ringtone=UINT(value,**{'sizeinbytes': 1}) 0867 0868 def __delfield_ringtone(self): del self.__field_ringtone 0869 0870 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, "ringtone index for a call") 0871 0872 def __getfield_unknown12(self): 0873 return self.__field_unknown12.getvalue() 0874 0875 def __setfield_unknown12(self, value): 0876 if isinstance(value,UINT): 0877 self.__field_unknown12=value 0878 else: 0879 self.__field_unknown12=UINT(value,**{'sizeinbytes': 1}) 0880 0881 def __delfield_unknown12(self): del self.__field_unknown12 0882 0883 unknown12=property(__getfield_unknown12, __setfield_unknown12, __delfield_unknown12, None) 0884 0885 def __getfield_unknown13(self): 0886 try: self.__field_unknown13 0887 except: 0888 self.__field_unknown13=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 0889 return self.__field_unknown13.getvalue() 0890 0891 def __setfield_unknown13(self, value): 0892 if isinstance(value,UINT): 0893 self.__field_unknown13=value 0894 else: 0895 self.__field_unknown13=UINT(value,**{'sizeinbytes': 1, 'constant': 0x00}) 0896 0897 def __delfield_unknown13(self): del self.__field_unknown13 0898 0899 unknown13=property(__getfield_unknown13, __setfield_unknown13, __delfield_unknown13, None) 0900 0901 def __getfield_memo(self): 0902 return self.__field_memo.getvalue() 0903 0904 def __setfield_memo(self, value): 0905 if isinstance(value,USTRING): 0906 self.__field_memo=value 0907 else: 0908 self.__field_memo=USTRING(value,**{'raiseonunterminatedread': False, 'sizeinbytes': MEMOLENGTH}) 0909 0910 def __delfield_memo(self): del self.__field_memo 0911 0912 memo=property(__getfield_memo, __setfield_memo, __delfield_memo, None) 0913 0914 def __getfield_emails(self): 0915 try: self.__field_emails 0916 except: 0917 self.__field_emails=LIST(**{'elementclass': _gen_p_lgvi125_134, 'length': NUMEMAILS}) 0918 return self.__field_emails.getvalue() 0919 0920 def __setfield_emails(self, value): 0921 if isinstance(value,LIST): 0922 self.__field_emails=value 0923 else: 0924 self.__field_emails=LIST(value,**{'elementclass': _gen_p_lgvi125_134, 'length': NUMEMAILS}) 0925 0926 def __delfield_emails(self): del self.__field_emails 0927 0928 emails=property(__getfield_emails, __setfield_emails, __delfield_emails, None) 0929 0930 def __getfield_url(self): 0931 return self.__field_url.getvalue() 0932 0933 def __setfield_url(self, value): 0934 if isinstance(value,USTRING): 0935 self.__field_url=value 0936 else: 0937 self.__field_url=USTRING(value,**{'sizeinbytes': 73, 'raiseonunterminatedread': False}) 0938 0939 def __delfield_url(self): del self.__field_url 0940 0941 url=property(__getfield_url, __setfield_url, __delfield_url, None) 0942 0943 def __getfield_avatar(self): 0944 return self.__field_avatar.getvalue() 0945 0946 def __setfield_avatar(self, value): 0947 if isinstance(value,UINT): 0948 self.__field_avatar=value 0949 else: 0950 self.__field_avatar=UINT(value,**{'sizeinbytes': 4}) 0951 0952 def __delfield_avatar(self): del self.__field_avatar 0953 0954 avatar=property(__getfield_avatar, __setfield_avatar, __delfield_avatar, None) 0955 0956 def __getfield_numberspeeddials(self): 0957 try: self.__field_numberspeeddials 0958 except: 0959 self.__field_numberspeeddials=LIST(**{'elementclass': _gen_p_lgvi125_138, 'length': NUMPHONENUMBERS}) 0960 return self.__field_numberspeeddials.getvalue() 0961 0962 def __setfield_numberspeeddials(self, value): 0963 if isinstance(value,LIST): 0964 self.__field_numberspeeddials=value 0965 else: 0966 self.__field_numberspeeddials=LIST(value,**{'elementclass': _gen_p_lgvi125_138, 'length': NUMPHONENUMBERS}) 0967 0968 def __delfield_numberspeeddials(self): del self.__field_numberspeeddials 0969 0970 numberspeeddials=property(__getfield_numberspeeddials, __setfield_numberspeeddials, __delfield_numberspeeddials, None) 0971 0972 def __getfield_numbertypes(self): 0973 try: self.__field_numbertypes 0974 except: 0975 self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lgvi125_140, 'length': NUMPHONENUMBERS}) 0976 return self.__field_numbertypes.getvalue() 0977 0978 def __setfield_numbertypes(self, value): 0979 if isinstance(value,LIST): 0980 self.__field_numbertypes=value 0981 else: 0982 self.__field_numbertypes=LIST(value,**{'elementclass': _gen_p_lgvi125_140, 'length': NUMPHONENUMBERS}) 0983 0984 def __delfield_numbertypes(self): del self.__field_numbertypes 0985 0986 numbertypes=property(__getfield_numbertypes, __setfield_numbertypes, __delfield_numbertypes, None) 0987 0988 def __getfield_numbers(self): 0989 try: self.__field_numbers 0990 except: 0991 self.__field_numbers=LIST(**{'elementclass': _gen_p_lgvi125_142, 'length': NUMPHONENUMBERS}) 0992 return self.__field_numbers.getvalue() 0993 0994 def __setfield_numbers(self, value): 0995 if isinstance(value,LIST): 0996 self.__field_numbers=value 0997 else: 0998 self.__field_numbers=LIST(value,**{'elementclass': _gen_p_lgvi125_142, 'length': NUMPHONENUMBERS}) 0999 1000 def __delfield_numbers(self): del self.__field_numbers 1001 1002 numbers=property(__getfield_numbers, __setfield_numbers, __delfield_numbers, None) 1003 1004 def __getfield_unknown14(self): 1005 try: self.__field_unknown14 1006 except: 1007 self.__field_unknown14=UINT(**{'sizeinbytes': 1, 'constant': 0x7c}) 1008 return self.__field_unknown14.getvalue() 1009 1010 def __setfield_unknown14(self, value): 1011 if isinstance(value,UINT): 1012 self.__field_unknown14=value 1013 else: 1014 self.__field_unknown14=UINT(value,**{'sizeinbytes': 1, 'constant': 0x7c}) 1015 1016 def __delfield_unknown14(self): del self.__field_unknown14 1017 1018 unknown14=property(__getfield_unknown14, __setfield_unknown14, __delfield_unknown14, None) 1019 1020 def iscontainer(self): 1021 return True 1022 1023 def containerelements(self): 1024 yield ('serial1', self.__field_serial1, None) 1025 yield ('unknown3', self.__field_unknown3, None) 1026 yield ('unknown4', self.__field_unknown4, None) 1027 yield ('unknown5', self.__field_unknown5, None) 1028 yield ('unknown6', self.__field_unknown6, None) 1029 yield ('unknown7', self.__field_unknown7, None) 1030 yield ('serial2', self.__field_serial2, None) 1031 yield ('unknown8', self.__field_unknown8, None) 1032 yield ('unknown9', self.__field_unknown9, None) 1033 yield ('unknown10', self.__field_unknown10, None) 1034 yield ('name', self.__field_name, None) 1035 yield ('group', self.__field_group, None) 1036 yield ('unknown11', self.__field_unknown11, None) 1037 yield ('ringtone', self.__field_ringtone, "ringtone index for a call") 1038 yield ('unknown12', self.__field_unknown12, None) 1039 yield ('unknown13', self.__field_unknown13, None) 1040 yield ('memo', self.__field_memo, None) 1041 yield ('emails', self.__field_emails, None) 1042 yield ('url', self.__field_url, None) 1043 yield ('avatar', self.__field_avatar, None) 1044 yield ('numberspeeddials', self.__field_numberspeeddials, None) 1045 yield ('numbertypes', self.__field_numbertypes, None) 1046 yield ('numbers', self.__field_numbers, None) 1047 yield ('unknown14', self.__field_unknown14, None) 1048 1049 1050 1051 1052 class _gen_p_lgvi125_134(BaseProtogenClass): 1053 'Anonymous inner class' 1054 __fields=['email'] 1055 1056 def __init__(self, *args, **kwargs): 1057 dict={} 1058 # What was supplied to this function 1059 dict.update(kwargs) 1060 # Parent constructor 1061 super(_gen_p_lgvi125_134,self).__init__(**dict) 1062 if self.__class__ is _gen_p_lgvi125_134: 1063 self._update(args,dict) 1064 1065 1066 def getfields(self): 1067 return self.__fields 1068 1069 1070 def _update(self, args, kwargs): 1071 super(_gen_p_lgvi125_134,self)._update(args,kwargs) 1072 keys=kwargs.keys() 1073 for key in keys: 1074 if key in self.__fields: 1075 setattr(self, key, kwargs[key]) 1076 del kwargs[key] 1077 # Were any unrecognized kwargs passed in? 1078 if __debug__: 1079 self._complainaboutunusedargs(_gen_p_lgvi125_134,kwargs) 1080 if len(args): 1081 dict2={'sizeinbytes': 73, 'raiseonunterminatedread': False} 1082 dict2.update(kwargs) 1083 kwargs=dict2 1084 self.__field_email=USTRING(*args,**dict2) 1085 # Make all P fields that haven't already been constructed 1086 1087 1088 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1089 'Writes this packet to the supplied buffer' 1090 self._bufferstartoffset=buf.getcurrentoffset() 1091 self.__field_email.writetobuffer(buf) 1092 self._bufferendoffset=buf.getcurrentoffset() 1093 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1094 1095 1096 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1097 'Reads this packet from the supplied buffer' 1098 self._bufferstartoffset=buf.getcurrentoffset() 1099 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1100 self.__field_email=USTRING(**{'sizeinbytes': 73, 'raiseonunterminatedread': False}) 1101 self.__field_email.readfrombuffer(buf) 1102 self._bufferendoffset=buf.getcurrentoffset() 1103 1104 1105 def __getfield_email(self): 1106 return self.__field_email.getvalue() 1107 1108 def __setfield_email(self, value): 1109 if isinstance(value,USTRING): 1110 self.__field_email=value 1111 else: 1112 self.__field_email=USTRING(value,**{'sizeinbytes': 73, 'raiseonunterminatedread': False}) 1113 1114 def __delfield_email(self): del self.__field_email 1115 1116 email=property(__getfield_email, __setfield_email, __delfield_email, None) 1117 1118 def iscontainer(self): 1119 return True 1120 1121 def containerelements(self): 1122 yield ('email', self.__field_email, None) 1123 1124 1125 1126 1127 class _gen_p_lgvi125_138(BaseProtogenClass): 1128 'Anonymous inner class' 1129 __fields=['numberspeeddial'] 1130 1131 def __init__(self, *args, **kwargs): 1132 dict={} 1133 # What was supplied to this function 1134 dict.update(kwargs) 1135 # Parent constructor 1136 super(_gen_p_lgvi125_138,self).__init__(**dict) 1137 if self.__class__ is _gen_p_lgvi125_138: 1138 self._update(args,dict) 1139 1140 1141 def getfields(self): 1142 return self.__fields 1143 1144 1145 def _update(self, args, kwargs): 1146 super(_gen_p_lgvi125_138,self)._update(args,kwargs) 1147 keys=kwargs.keys() 1148 for key in keys: 1149 if key in self.__fields: 1150 setattr(self, key, kwargs[key]) 1151 del kwargs[key] 1152 # Were any unrecognized kwargs passed in? 1153 if __debug__: 1154 self._complainaboutunusedargs(_gen_p_lgvi125_138,kwargs) 1155 if len(args): 1156 dict2={'sizeinbytes': 1} 1157 dict2.update(kwargs) 1158 kwargs=dict2 1159 self.__field_numberspeeddial=UINT(*args,**dict2) 1160 # Make all P fields that haven't already been constructed 1161 1162 1163 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1164 'Writes this packet to the supplied buffer' 1165 self._bufferstartoffset=buf.getcurrentoffset() 1166 self.__field_numberspeeddial.writetobuffer(buf) 1167 self._bufferendoffset=buf.getcurrentoffset() 1168 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1169 1170 1171 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1172 'Reads this packet from the supplied buffer' 1173 self._bufferstartoffset=buf.getcurrentoffset() 1174 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1175 self.__field_numberspeeddial=UINT(**{'sizeinbytes': 1}) 1176 self.__field_numberspeeddial.readfrombuffer(buf) 1177 self._bufferendoffset=buf.getcurrentoffset() 1178 1179 1180 def __getfield_numberspeeddial(self): 1181 return self.__field_numberspeeddial.getvalue() 1182 1183 def __setfield_numberspeeddial(self, value): 1184 if isinstance(value,UINT): 1185 self.__field_numberspeeddial=value 1186 else: 1187 self.__field_numberspeeddial=UINT(value,**{'sizeinbytes': 1}) 1188 1189 def __delfield_numberspeeddial(self): del self.__field_numberspeeddial 1190 1191 numberspeeddial=property(__getfield_numberspeeddial, __setfield_numberspeeddial, __delfield_numberspeeddial, None) 1192 1193 def iscontainer(self): 1194 return True 1195 1196 def containerelements(self): 1197 yield ('numberspeeddial', self.__field_numberspeeddial, None) 1198 1199 1200 1201 1202 class _gen_p_lgvi125_140(BaseProtogenClass): 1203 'Anonymous inner class' 1204 __fields=['numbertype'] 1205 1206 def __init__(self, *args, **kwargs): 1207 dict={} 1208 # What was supplied to this function 1209 dict.update(kwargs) 1210 # Parent constructor 1211 super(_gen_p_lgvi125_140,self).__init__(**dict) 1212 if self.__class__ is _gen_p_lgvi125_140: 1213 self._update(args,dict) 1214 1215 1216 def getfields(self): 1217 return self.__fields 1218 1219 1220 def _update(self, args, kwargs): 1221 super(_gen_p_lgvi125_140,self)._update(args,kwargs) 1222 keys=kwargs.keys() 1223 for key in keys: 1224 if key in self.__fields: 1225 setattr(self, key, kwargs[key]) 1226 del kwargs[key] 1227 # Were any unrecognized kwargs passed in? 1228 if __debug__: 1229 self._complainaboutunusedargs(_gen_p_lgvi125_140,kwargs) 1230 if len(args): 1231 dict2={'sizeinbytes': 1} 1232 dict2.update(kwargs) 1233 kwargs=dict2 1234 self.__field_numbertype=UINT(*args,**dict2) 1235 # Make all P fields that haven't already been constructed 1236 1237 1238 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1239 'Writes this packet to the supplied buffer' 1240 self._bufferstartoffset=buf.getcurrentoffset() 1241 self.__field_numbertype.writetobuffer(buf) 1242 self._bufferendoffset=buf.getcurrentoffset() 1243 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1244 1245 1246 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1247 'Reads this packet from the supplied buffer' 1248 self._bufferstartoffset=buf.getcurrentoffset() 1249 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1250 self.__field_numbertype=UINT(**{'sizeinbytes': 1}) 1251 self.__field_numbertype.readfrombuffer(buf) 1252 self._bufferendoffset=buf.getcurrentoffset() 1253 1254 1255 def __getfield_numbertype(self): 1256 return self.__field_numbertype.getvalue() 1257 1258 def __setfield_numbertype(self, value): 1259 if isinstance(value,UINT): 1260 self.__field_numbertype=value 1261 else: 1262 self.__field_numbertype=UINT(value,**{'sizeinbytes': 1}) 1263 1264 def __delfield_numbertype(self): del self.__field_numbertype 1265 1266 numbertype=property(__getfield_numbertype, __setfield_numbertype, __delfield_numbertype, None) 1267 1268 def iscontainer(self): 1269 return True 1270 1271 def containerelements(self): 1272 yield ('numbertype', self.__field_numbertype, None) 1273 1274 1275 1276 1277 class _gen_p_lgvi125_142(BaseProtogenClass): 1278 'Anonymous inner class' 1279 __fields=['number'] 1280 1281 def __init__(self, *args, **kwargs): 1282 dict={} 1283 # What was supplied to this function 1284 dict.update(kwargs) 1285 # Parent constructor 1286 super(_gen_p_lgvi125_142,self).__init__(**dict) 1287 if self.__class__ is _gen_p_lgvi125_142: 1288 self._update(args,dict) 1289 1290 1291 def getfields(self): 1292 return self.__fields 1293 1294 1295 def _update(self, args, kwargs): 1296 super(_gen_p_lgvi125_142,self)._update(args,kwargs) 1297 keys=kwargs.keys() 1298 for key in keys: 1299 if key in self.__fields: 1300 setattr(self, key, kwargs[key]) 1301 del kwargs[key] 1302 # Were any unrecognized kwargs passed in? 1303 if __debug__: 1304 self._complainaboutunusedargs(_gen_p_lgvi125_142,kwargs) 1305 if len(args): 1306 dict2={'sizeinbytes': 49, 'raiseonunterminatedread': False} 1307 dict2.update(kwargs) 1308 kwargs=dict2 1309 self.__field_number=USTRING(*args,**dict2) 1310 # Make all P fields that haven't already been constructed 1311 1312 1313 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1314 'Writes this packet to the supplied buffer' 1315 self._bufferstartoffset=buf.getcurrentoffset() 1316 self.__field_number.writetobuffer(buf) 1317 self._bufferendoffset=buf.getcurrentoffset() 1318 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1319 1320 1321 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1322 'Reads this packet from the supplied buffer' 1323 self._bufferstartoffset=buf.getcurrentoffset() 1324 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1325 self.__field_number=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 1326 self.__field_number.readfrombuffer(buf) 1327 self._bufferendoffset=buf.getcurrentoffset() 1328 1329 1330 def __getfield_number(self): 1331 return self.__field_number.getvalue() 1332 1333 def __setfield_number(self, value): 1334 if isinstance(value,USTRING): 1335 self.__field_number=value 1336 else: 1337 self.__field_number=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 1338 1339 def __delfield_number(self): del self.__field_number 1340 1341 number=property(__getfield_number, __setfield_number, __delfield_number, None) 1342 1343 def iscontainer(self): 1344 return True 1345 1346 def containerelements(self): 1347 yield ('number', self.__field_number, None) 1348 1349 1350 1351 1352 class pbgroup(BaseProtogenClass): 1353 "A single group" 1354 __fields=['number', 'unknown1', 'ring', 'unknown2', 'unknown3', 'unknown4', 'unknown5', 'unknown6', 'unknown7', 'unknown8', 'name'] 1355 1356 def __init__(self, *args, **kwargs): 1357 dict={} 1358 # What was supplied to this function 1359 dict.update(kwargs) 1360 # Parent constructor 1361 super(pbgroup,self).__init__(**dict) 1362 if self.__class__ is pbgroup: 1363 self._update(args,dict) 1364 1365 1366 def getfields(self): 1367 return self.__fields 1368 1369 1370 def _update(self, args, kwargs): 1371 super(pbgroup,self)._update(args,kwargs) 1372 keys=kwargs.keys() 1373 for key in keys: 1374 if key in self.__fields: 1375 setattr(self, key, kwargs[key]) 1376 del kwargs[key] 1377 # Were any unrecognized kwargs passed in? 1378 if __debug__: 1379 self._complainaboutunusedargs(pbgroup,kwargs) 1380 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 1381 # Make all P fields that haven't already been constructed 1382 1383 1384 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1385 'Writes this packet to the supplied buffer' 1386 self._bufferstartoffset=buf.getcurrentoffset() 1387 self.__field_number.writetobuffer(buf) 1388 self.__field_unknown1.writetobuffer(buf) 1389 self.__field_ring.writetobuffer(buf) 1390 try: self.__field_unknown2 1391 except: 1392 self.__field_unknown2=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 1393 self.__field_unknown2.writetobuffer(buf) 1394 try: self.__field_unknown3 1395 except: 1396 self.__field_unknown3=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 1397 self.__field_unknown3.writetobuffer(buf) 1398 try: self.__field_unknown4 1399 except: 1400 self.__field_unknown4=UINT(**{'sizeinbytes': 1, 'constant': 0x01}) 1401 self.__field_unknown4.writetobuffer(buf) 1402 try: self.__field_unknown5 1403 except: 1404 self.__field_unknown5=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 1405 self.__field_unknown5.writetobuffer(buf) 1406 try: self.__field_unknown6 1407 except: 1408 self.__field_unknown6=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 1409 self.__field_unknown6.writetobuffer(buf) 1410 self.__field_unknown7.writetobuffer(buf) 1411 self.__field_unknown8.writetobuffer(buf) 1412 self.__field_name.writetobuffer(buf) 1413 self._bufferendoffset=buf.getcurrentoffset() 1414 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1415 1416 1417 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1418 'Reads this packet from the supplied buffer' 1419 self._bufferstartoffset=buf.getcurrentoffset() 1420 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1421 self.__field_number=UINT(**{'sizeinbytes': 1}) 1422 self.__field_number.readfrombuffer(buf) 1423 self.__field_unknown1=UINT(**{'sizeinbytes': 1}) 1424 self.__field_unknown1.readfrombuffer(buf) 1425 self.__field_ring=UINT(**{'sizeinbytes': 1}) 1426 self.__field_ring.readfrombuffer(buf) 1427 self.__field_unknown2=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 1428 self.__field_unknown2.readfrombuffer(buf) 1429 self.__field_unknown3=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 1430 self.__field_unknown3.readfrombuffer(buf) 1431 self.__field_unknown4=UINT(**{'sizeinbytes': 1, 'constant': 0x01}) 1432 self.__field_unknown4.readfrombuffer(buf) 1433 self.__field_unknown5=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 1434 self.__field_unknown5.readfrombuffer(buf) 1435 self.__field_unknown6=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 1436 self.__field_unknown6.readfrombuffer(buf) 1437 self.__field_unknown7=UINT(**{'sizeinbytes': 1}) 1438 self.__field_unknown7.readfrombuffer(buf) 1439 self.__field_unknown8=UINT(**{'sizeinbytes': 1}) 1440 self.__field_unknown8.readfrombuffer(buf) 1441 self.__field_name=USTRING(**{'sizeinbytes': 33}) 1442 self.__field_name.readfrombuffer(buf) 1443 self._bufferendoffset=buf.getcurrentoffset() 1444 1445 1446 def __getfield_number(self): 1447 return self.__field_number.getvalue() 1448 1449 def __setfield_number(self, value): 1450 if isinstance(value,UINT): 1451 self.__field_number=value 1452 else: 1453 self.__field_number=UINT(value,**{'sizeinbytes': 1}) 1454 1455 def __delfield_number(self): del self.__field_number 1456 1457 number=property(__getfield_number, __setfield_number, __delfield_number, None) 1458 1459 def __getfield_unknown1(self): 1460 return self.__field_unknown1.getvalue() 1461 1462 def __setfield_unknown1(self, value): 1463 if isinstance(value,UINT): 1464 self.__field_unknown1=value 1465 else: 1466 self.__field_unknown1=UINT(value,**{'sizeinbytes': 1}) 1467 1468 def __delfield_unknown1(self): del self.__field_unknown1 1469 1470 unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 1471 1472 def __getfield_ring(self): 1473 return self.__field_ring.getvalue() 1474 1475 def __setfield_ring(self, value): 1476 if isinstance(value,UINT): 1477 self.__field_ring=value 1478 else: 1479 self.__field_ring=UINT(value,**{'sizeinbytes': 1}) 1480 1481 def __delfield_ring(self): del self.__field_ring 1482 1483 ring=property(__getfield_ring, __setfield_ring, __delfield_ring, None) 1484 1485 def __getfield_unknown2(self): 1486 try: self.__field_unknown2 1487 except: 1488 self.__field_unknown2=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 1489 return self.__field_unknown2.getvalue() 1490 1491 def __setfield_unknown2(self, value): 1492 if isinstance(value,UINT): 1493 self.__field_unknown2=value 1494 else: 1495 self.__field_unknown2=UINT(value,**{'sizeinbytes': 1, 'constant': 0x00}) 1496 1497 def __delfield_unknown2(self): del self.__field_unknown2 1498 1499 unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None) 1500 1501 def __getfield_unknown3(self): 1502 try: self.__field_unknown3 1503 except: 1504 self.__field_unknown3=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 1505 return self.__field_unknown3.getvalue() 1506 1507 def __setfield_unknown3(self, value): 1508 if isinstance(value,UINT): 1509 self.__field_unknown3=value 1510 else: 1511 self.__field_unknown3=UINT(value,**{'sizeinbytes': 1, 'constant': 0x00}) 1512 1513 def __delfield_unknown3(self): del self.__field_unknown3 1514 1515 unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None) 1516 1517 def __getfield_unknown4(self): 1518 try: self.__field_unknown4 1519 except: 1520 self.__field_unknown4=UINT(**{'sizeinbytes': 1, 'constant': 0x01}) 1521 return self.__field_unknown4.getvalue() 1522 1523 def __setfield_unknown4(self, value): 1524 if isinstance(value,UINT): 1525 self.__field_unknown4=value 1526 else: 1527 self.__field_unknown4=UINT(value,**{'sizeinbytes': 1, 'constant': 0x01}) 1528 1529 def __delfield_unknown4(self): del self.__field_unknown4 1530 1531 unknown4=property(__getfield_unknown4, __setfield_unknown4, __delfield_unknown4, None) 1532 1533 def __getfield_unknown5(self): 1534 try: self.__field_unknown5 1535 except: 1536 self.__field_unknown5=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 1537 return self.__field_unknown5.getvalue() 1538 1539 def __setfield_unknown5(self, value): 1540 if isinstance(value,UINT): 1541 self.__field_unknown5=value 1542 else: 1543 self.__field_unknown5=UINT(value,**{'sizeinbytes': 1, 'constant': 0x00}) 1544 1545 def __delfield_unknown5(self): del self.__field_unknown5 1546 1547 unknown5=property(__getfield_unknown5, __setfield_unknown5, __delfield_unknown5, None) 1548 1549 def __getfield_unknown6(self): 1550 try: self.__field_unknown6 1551 except: 1552 self.__field_unknown6=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 1553 return self.__field_unknown6.getvalue() 1554 1555 def __setfield_unknown6(self, value): 1556 if isinstance(value,UINT): 1557 self.__field_unknown6=value 1558 else: 1559 self.__field_unknown6=UINT(value,**{'sizeinbytes': 1, 'constant': 0x00}) 1560 1561 def __delfield_unknown6(self): del self.__field_unknown6 1562 1563 unknown6=property(__getfield_unknown6, __setfield_unknown6, __delfield_unknown6, None) 1564 1565 def __getfield_unknown7(self): 1566 return self.__field_unknown7.getvalue() 1567 1568 def __setfield_unknown7(self, value): 1569 if isinstance(value,UINT): 1570 self.__field_unknown7=value 1571 else: 1572 self.__field_unknown7=UINT(value,**{'sizeinbytes': 1}) 1573 1574 def __delfield_unknown7(self): del self.__field_unknown7 1575 1576 unknown7=property(__getfield_unknown7, __setfield_unknown7, __delfield_unknown7, None) 1577 1578 def __getfield_unknown8(self): 1579 return self.__field_unknown8.getvalue() 1580 1581 def __setfield_unknown8(self, value): 1582 if isinstance(value,UINT): 1583 self.__field_unknown8=value 1584 else: 1585 self.__field_unknown8=UINT(value,**{'sizeinbytes': 1}) 1586 1587 def __delfield_unknown8(self): del self.__field_unknown8 1588 1589 unknown8=property(__getfield_unknown8, __setfield_unknown8, __delfield_unknown8, None) 1590 1591 def __getfield_name(self): 1592 return self.__field_name.getvalue() 1593 1594 def __setfield_name(self, value): 1595 if isinstance(value,USTRING): 1596 self.__field_name=value 1597 else: 1598 self.__field_name=USTRING(value,**{'sizeinbytes': 33}) 1599 1600 def __delfield_name(self): del self.__field_name 1601 1602 name=property(__getfield_name, __setfield_name, __delfield_name, None) 1603 1604 def iscontainer(self): 1605 return True 1606 1607 def containerelements(self): 1608 yield ('number', self.__field_number, None) 1609 yield ('unknown1', self.__field_unknown1, None) 1610 yield ('ring', self.__field_ring, None) 1611 yield ('unknown2', self.__field_unknown2, None) 1612 yield ('unknown3', self.__field_unknown3, None) 1613 yield ('unknown4', self.__field_unknown4, None) 1614 yield ('unknown5', self.__field_unknown5, None) 1615 yield ('unknown6', self.__field_unknown6, None) 1616 yield ('unknown7', self.__field_unknown7, None) 1617 yield ('unknown8', self.__field_unknown8, None) 1618 yield ('name', self.__field_name, None) 1619 1620 1621 1622 1623 class pbgroups(BaseProtogenClass): 1624 "Phonebook groups" 1625 __fields=['groups'] 1626 1627 def __init__(self, *args, **kwargs): 1628 dict={} 1629 # What was supplied to this function 1630 dict.update(kwargs) 1631 # Parent constructor 1632 super(pbgroups,self).__init__(**dict) 1633 if self.__class__ is pbgroups: 1634 self._update(args,dict) 1635 1636 1637 def getfields(self): 1638 return self.__fields 1639 1640 1641 def _update(self, args, kwargs): 1642 super(pbgroups,self)._update(args,kwargs) 1643 keys=kwargs.keys() 1644 for key in keys: 1645 if key in self.__fields: 1646 setattr(self, key, kwargs[key]) 1647 del kwargs[key] 1648 # Were any unrecognized kwargs passed in? 1649 if __debug__: 1650 self._complainaboutunusedargs(pbgroups,kwargs) 1651 if len(args): 1652 dict2={'elementclass': pbgroup} 1653 dict2.update(kwargs) 1654 kwargs=dict2 1655 self.__field_groups=LIST(*args,**dict2) 1656 # Make all P fields that haven't already been constructed 1657 1658 1659 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1660 'Writes this packet to the supplied buffer' 1661 self._bufferstartoffset=buf.getcurrentoffset() 1662 try: self.__field_groups 1663 except: 1664 self.__field_groups=LIST(**{'elementclass': pbgroup}) 1665 self.__field_groups.writetobuffer(buf) 1666 self._bufferendoffset=buf.getcurrentoffset() 1667 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1668 1669 1670 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1671 'Reads this packet from the supplied buffer' 1672 self._bufferstartoffset=buf.getcurrentoffset() 1673 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1674 self.__field_groups=LIST(**{'elementclass': pbgroup}) 1675 self.__field_groups.readfrombuffer(buf) 1676 self._bufferendoffset=buf.getcurrentoffset() 1677 1678 1679 def __getfield_groups(self): 1680 try: self.__field_groups 1681 except: 1682 self.__field_groups=LIST(**{'elementclass': pbgroup}) 1683 return self.__field_groups.getvalue() 1684 1685 def __setfield_groups(self, value): 1686 if isinstance(value,LIST): 1687 self.__field_groups=value 1688 else: 1689 self.__field_groups=LIST(value,**{'elementclass': pbgroup}) 1690 1691 def __delfield_groups(self): del self.__field_groups 1692 1693 groups=property(__getfield_groups, __setfield_groups, __delfield_groups, None) 1694 1695 def iscontainer(self): 1696 return True 1697 1698 def containerelements(self): 1699 yield ('groups', self.__field_groups, None) 1700 1701 1702 1703 1704 class pbseqgroup(BaseProtogenClass): 1705 __fields=['number', 'unknown'] 1706 1707 def __init__(self, *args, **kwargs): 1708 dict={} 1709 # What was supplied to this function 1710 dict.update(kwargs) 1711 # Parent constructor 1712 super(pbseqgroup,self).__init__(**dict) 1713 if self.__class__ is pbseqgroup: 1714 self._update(args,dict) 1715 1716 1717 def getfields(self): 1718 return self.__fields 1719 1720 1721 def _update(self, args, kwargs): 1722 super(pbseqgroup,self)._update(args,kwargs) 1723 keys=kwargs.keys() 1724 for key in keys: 1725 if key in self.__fields: 1726 setattr(self, key, kwargs[key]) 1727 del kwargs[key] 1728 # Were any unrecognized kwargs passed in? 1729 if __debug__: 1730 self._complainaboutunusedargs(pbseqgroup,kwargs) 1731 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 1732 # Make all P fields that haven't already been constructed 1733 1734 1735 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1736 'Writes this packet to the supplied buffer' 1737 self._bufferstartoffset=buf.getcurrentoffset() 1738 self.__field_number.writetobuffer(buf) 1739 self.__field_unknown.writetobuffer(buf) 1740 self._bufferendoffset=buf.getcurrentoffset() 1741 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1742 1743 1744 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1745 'Reads this packet from the supplied buffer' 1746 self._bufferstartoffset=buf.getcurrentoffset() 1747 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1748 self.__field_number=UINT(**{'sizeinbytes': 1}) 1749 self.__field_number.readfrombuffer(buf) 1750 self.__field_unknown=UINT(**{'sizeinbytes': 1}) 1751 self.__field_unknown.readfrombuffer(buf) 1752 self._bufferendoffset=buf.getcurrentoffset() 1753 1754 1755 def __getfield_number(self): 1756 return self.__field_number.getvalue() 1757 1758 def __setfield_number(self, value): 1759 if isinstance(value,UINT): 1760 self.__field_number=value 1761 else: 1762 self.__field_number=UINT(value,**{'sizeinbytes': 1}) 1763 1764 def __delfield_number(self): del self.__field_number 1765 1766 number=property(__getfield_number, __setfield_number, __delfield_number, None) 1767 1768 def __getfield_unknown(self): 1769 return self.__field_unknown.getvalue() 1770 1771 def __setfield_unknown(self, value): 1772 if isinstance(value,UINT): 1773 self.__field_unknown=value 1774 else: 1775 self.__field_unknown=UINT(value,**{'sizeinbytes': 1}) 1776 1777 def __delfield_unknown(self): del self.__field_unknown 1778 1779 unknown=property(__getfield_unknown, __setfield_unknown, __delfield_unknown, None) 1780 1781 def iscontainer(self): 1782 return True 1783 1784 def containerelements(self): 1785 yield ('number', self.__field_number, None) 1786 yield ('unknown', self.__field_unknown, None) 1787 1788 1789 1790 1791 class pbseqgroups(BaseProtogenClass): 1792 __fields=['seqgroups'] 1793 1794 def __init__(self, *args, **kwargs): 1795 dict={} 1796 # What was supplied to this function 1797 dict.update(kwargs) 1798 # Parent constructor 1799 super(pbseqgroups,self).__init__(**dict) 1800 if self.__class__ is pbseqgroups: 1801 self._update(args,dict) 1802 1803 1804 def getfields(self): 1805 return self.__fields 1806 1807 1808 def _update(self, args, kwargs): 1809 super(pbseqgroups,self)._update(args,kwargs) 1810 keys=kwargs.keys() 1811 for key in keys: 1812 if key in self.__fields: 1813 setattr(self, key, kwargs[key]) 1814 del kwargs[key] 1815 # Were any unrecognized kwargs passed in? 1816 if __debug__: 1817 self._complainaboutunusedargs(pbseqgroups,kwargs) 1818 if len(args): 1819 dict2={'elementclass': pbseqgroup, 'length': NUMGROUPS} 1820 dict2.update(kwargs) 1821 kwargs=dict2 1822 self.__field_seqgroups=LIST(*args,**dict2) 1823 # Make all P fields that haven't already been constructed 1824 1825 1826 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1827 'Writes this packet to the supplied buffer' 1828 self._bufferstartoffset=buf.getcurrentoffset() 1829 try: self.__field_seqgroups 1830 except: 1831 self.__field_seqgroups=LIST(**{'elementclass': pbseqgroup, 'length': NUMGROUPS}) 1832 self.__field_seqgroups.writetobuffer(buf) 1833 self._bufferendoffset=buf.getcurrentoffset() 1834 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1835 1836 1837 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1838 'Reads this packet from the supplied buffer' 1839 self._bufferstartoffset=buf.getcurrentoffset() 1840 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1841 self.__field_seqgroups=LIST(**{'elementclass': pbseqgroup, 'length': NUMGROUPS}) 1842 self.__field_seqgroups.readfrombuffer(buf) 1843 self._bufferendoffset=buf.getcurrentoffset() 1844 1845 1846 def __getfield_seqgroups(self): 1847 try: self.__field_seqgroups 1848 except: 1849 self.__field_seqgroups=LIST(**{'elementclass': pbseqgroup, 'length': NUMGROUPS}) 1850 return self.__field_seqgroups.getvalue() 1851 1852 def __setfield_seqgroups(self, value): 1853 if isinstance(value,LIST): 1854 self.__field_seqgroups=value 1855 else: 1856 self.__field_seqgroups=LIST(value,**{'elementclass': pbseqgroup, 'length': NUMGROUPS}) 1857 1858 def __delfield_seqgroups(self): del self.__field_seqgroups 1859 1860 seqgroups=property(__getfield_seqgroups, __setfield_seqgroups, __delfield_seqgroups, None) 1861 1862 def iscontainer(self): 1863 return True 1864 1865 def containerelements(self): 1866 yield ('seqgroups', self.__field_seqgroups, None) 1867 1868 1869 1870 1871 class pbmapgroup(BaseProtogenClass): 1872 __fields=['number', 'unknown'] 1873 1874 def __init__(self, *args, **kwargs): 1875 dict={} 1876 # What was supplied to this function 1877 dict.update(kwargs) 1878 # Parent constructor 1879 super(pbmapgroup,self).__init__(**dict) 1880 if self.__class__ is pbmapgroup: 1881 self._update(args,dict) 1882 1883 1884 def getfields(self): 1885 return self.__fields 1886 1887 1888 def _update(self, args, kwargs): 1889 super(pbmapgroup,self)._update(args,kwargs) 1890 keys=kwargs.keys() 1891 for key in keys: 1892 if key in self.__fields: 1893 setattr(self, key, kwargs[key]) 1894 del kwargs[key] 1895 # Were any unrecognized kwargs passed in? 1896 if __debug__: 1897 self._complainaboutunusedargs(pbmapgroup,kwargs) 1898 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 1899 # Make all P fields that haven't already been constructed 1900 1901 1902 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1903 'Writes this packet to the supplied buffer' 1904 self._bufferstartoffset=buf.getcurrentoffset() 1905 self.__field_number.writetobuffer(buf) 1906 self.__field_unknown.writetobuffer(buf) 1907 self._bufferendoffset=buf.getcurrentoffset() 1908 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1909 1910 1911 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1912 'Reads this packet from the supplied buffer' 1913 self._bufferstartoffset=buf.getcurrentoffset() 1914 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1915 self.__field_number=UINT(**{'sizeinbytes': 1}) 1916 self.__field_number.readfrombuffer(buf) 1917 self.__field_unknown=UINT(**{'sizeinbytes': 1}) 1918 self.__field_unknown.readfrombuffer(buf) 1919 self._bufferendoffset=buf.getcurrentoffset() 1920 1921 1922 def __getfield_number(self): 1923 return self.__field_number.getvalue() 1924 1925 def __setfield_number(self, value): 1926 if isinstance(value,UINT): 1927 self.__field_number=value 1928 else: 1929 self.__field_number=UINT(value,**{'sizeinbytes': 1}) 1930 1931 def __delfield_number(self): del self.__field_number 1932 1933 number=property(__getfield_number, __setfield_number, __delfield_number, None) 1934 1935 def __getfield_unknown(self): 1936 return self.__field_unknown.getvalue() 1937 1938 def __setfield_unknown(self, value): 1939 if isinstance(value,UINT): 1940 self.__field_unknown=value 1941 else: 1942 self.__field_unknown=UINT(value,**{'sizeinbytes': 1}) 1943 1944 def __delfield_unknown(self): del self.__field_unknown 1945 1946 unknown=property(__getfield_unknown, __setfield_unknown, __delfield_unknown, None) 1947 1948 def iscontainer(self): 1949 return True 1950 1951 def containerelements(self): 1952 yield ('number', self.__field_number, None) 1953 yield ('unknown', self.__field_unknown, None) 1954 1955 1956 1957 1958 class pbmapgroups(BaseProtogenClass): 1959 __fields=['mapgroups'] 1960 1961 def __init__(self, *args, **kwargs): 1962 dict={} 1963 # What was supplied to this function 1964 dict.update(kwargs) 1965 # Parent constructor 1966 super(pbmapgroups,self).__init__(**dict) 1967 if self.__class__ is pbmapgroups: 1968 self._update(args,dict) 1969 1970 1971 def getfields(self): 1972 return self.__fields 1973 1974 1975 def _update(self, args, kwargs): 1976 super(pbmapgroups,self)._update(args,kwargs) 1977 keys=kwargs.keys() 1978 for key in keys: 1979 if key in self.__fields: 1980 setattr(self, key, kwargs[key]) 1981 del kwargs[key] 1982 # Were any unrecognized kwargs passed in? 1983 if __debug__: 1984 self._complainaboutunusedargs(pbmapgroups,kwargs) 1985 if len(args): 1986 dict2={'elementclass': pbmapgroup, 'length': NUMMAPGROUPS} 1987 dict2.update(kwargs) 1988 kwargs=dict2 1989 self.__field_mapgroups=LIST(*args,**dict2) 1990 # Make all P fields that haven't already been constructed 1991 1992 1993 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1994 'Writes this packet to the supplied buffer' 1995 self._bufferstartoffset=buf.getcurrentoffset() 1996 try: self.__field_mapgroups 1997 except: 1998 self.__field_mapgroups=LIST(**{'elementclass': pbmapgroup, 'length': NUMMAPGROUPS}) 1999 self.__field_mapgroups.writetobuffer(buf) 2000 self._bufferendoffset=buf.getcurrentoffset() 2001 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 2002 2003 2004 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 2005 'Reads this packet from the supplied buffer' 2006 self._bufferstartoffset=buf.getcurrentoffset() 2007 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 2008 self.__field_mapgroups=LIST(**{'elementclass': pbmapgroup, 'length': NUMMAPGROUPS}) 2009 self.__field_mapgroups.readfrombuffer(buf) 2010 self._bufferendoffset=buf.getcurrentoffset() 2011 2012 2013 def __getfield_mapgroups(self): 2014 try: self.__field_mapgroups 2015 except: 2016 self.__field_mapgroups=LIST(**{'elementclass': pbmapgroup, 'length': NUMMAPGROUPS}) 2017 return self.__field_mapgroups.getvalue() 2018 2019 def __setfield_mapgroups(self, value): 2020 if isinstance(value,LIST): 2021 self.__field_mapgroups=value 2022 else: 2023 self.__field_mapgroups=LIST(value,**{'elementclass': pbmapgroup, 'length': NUMMAPGROUPS}) 2024 2025 def __delfield_mapgroups(self): del self.__field_mapgroups 2026 2027 mapgroups=property(__getfield_mapgroups, __setfield_mapgroups, __delfield_mapgroups, None) 2028 2029 def iscontainer(self): 2030 return True 2031 2032 def containerelements(self): 2033 yield ('mapgroups', self.__field_mapgroups, None) 2034 2035 2036 2037 2038 class indexentry(BaseProtogenClass): 2039 __fields=['index', 'name'] 2040 2041 def __init__(self, *args, **kwargs): 2042 dict={} 2043 # What was supplied to this function 2044 dict.update(kwargs) 2045 # Parent constructor 2046 super(indexentry,self).__init__(**dict) 2047 if self.__class__ is indexentry: 2048 self._update(args,dict) 2049 2050 2051 def getfields(self): 2052 return self.__fields 2053 2054 2055 def _update(self, args, kwargs): 2056 super(indexentry,self)._update(args,kwargs) 2057 keys=kwargs.keys() 2058 for key in keys: 2059 if key in self.__fields: 2060 setattr(self, key, kwargs[key]) 2061 del kwargs[key] 2062 # Were any unrecognized kwargs passed in? 2063 if __debug__: 2064 self._complainaboutunusedargs(indexentry,kwargs) 2065 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 2066 # Make all P fields that haven't already been constructed 2067 2068 2069 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 2070 'Writes this packet to the supplied buffer' 2071 self._bufferstartoffset=buf.getcurrentoffset() 2072 try: self.__field_index 2073 except: 2074 self.__field_index=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 2075 self.__field_index.writetobuffer(buf) 2076 try: self.__field_name 2077 except: 2078 self.__field_name=USTRING(**{'sizeinbytes': 40, 'default': ""}) 2079 self.__field_name.writetobuffer(buf) 2080 self._bufferendoffset=buf.getcurrentoffset() 2081 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 2082 2083 2084 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 2085 'Reads this packet from the supplied buffer' 2086 self._bufferstartoffset=buf.getcurrentoffset() 2087 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 2088 self.__field_index=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 2089 self.__field_index.readfrombuffer(buf) 2090 self.__field_name=USTRING(**{'sizeinbytes': 40, 'default': ""}) 2091 self.__field_name.readfrombuffer(buf) 2092 self._bufferendoffset=buf.getcurrentoffset() 2093 2094 2095 def __getfield_index(self): 2096 try: self.__field_index 2097 except: 2098 self.__field_index=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 2099 return self.__field_index.getvalue() 2100 2101 def __setfield_index(self, value): 2102 if isinstance(value,UINT): 2103 self.__field_index=value 2104 else: 2105 self.__field_index=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff}) 2106 2107 def __delfield_index(self): del self.__field_index 2108 2109 index=property(__getfield_index, __setfield_index, __delfield_index, None) 2110 2111 def __getfield_name(self): 2112 try: self.__field_name 2113 except: 2114 self.__field_name=USTRING(**{'sizeinbytes': 40, 'default': ""}) 2115 return self.__field_name.getvalue() 2116 2117 def __setfield_name(self, value): 2118 if isinstance(value,USTRING): 2119 self.__field_name=value 2120 else: 2121 self.__field_name=USTRING(value,**{'sizeinbytes': 40, 'default': ""}) 2122 2123 def __delfield_name(self): del self.__field_name 2124 2125 name=property(__getfield_name, __setfield_name, __delfield_name, None) 2126 2127 def iscontainer(self): 2128 return True 2129 2130 def containerelements(self): 2131 yield ('index', self.__field_index, None) 2132 yield ('name', self.__field_name, None) 2133 2134 2135 2136 2137 class indexfile(BaseProtogenClass): 2138 "Used for tracking wallpaper and ringtones" 2139 __fields=['maxitems', 'numactiveitems', 'items'] 2140 2141 def __init__(self, *args, **kwargs): 2142 dict={} 2143 # What was supplied to this function 2144 dict.update(kwargs) 2145 # Parent constructor 2146 super(indexfile,self).__init__(**dict) 2147 if self.__class__ is indexfile: 2148 self._update(args,dict) 2149 2150 2151 def getfields(self): 2152 return self.__fields 2153 2154 2155 def _update(self, args, kwargs): 2156 super(indexfile,self)._update(args,kwargs) 2157 keys=kwargs.keys() 2158 for key in keys: 2159 if key in self.__fields: 2160 setattr(self, key, kwargs[key]) 2161 del kwargs[key] 2162 # Were any unrecognized kwargs passed in? 2163 if __debug__: 2164 self._complainaboutunusedargs(indexfile,kwargs) 2165 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 2166 # Make all P fields that haven't already been constructed 2167 try: self.__field_maxitems 2168 except: 2169 self.__field_maxitems=UINT(**{'constant': 30}) 2170 2171 2172 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 2173 'Writes this packet to the supplied buffer' 2174 self._bufferstartoffset=buf.getcurrentoffset() 2175 self.__field_numactiveitems.writetobuffer(buf) 2176 try: self.__field_items 2177 except: 2178 self.__field_items=LIST(**{'length': self.maxitems, 'elementclass': indexentry, 'createdefault': True}) 2179 self.__field_items.writetobuffer(buf) 2180 self._bufferendoffset=buf.getcurrentoffset() 2181 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 2182 2183 2184 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 2185 'Reads this packet from the supplied buffer' 2186 self._bufferstartoffset=buf.getcurrentoffset() 2187 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 2188 self.__field_numactiveitems=UINT(**{'sizeinbytes': 2}) 2189 self.__field_numactiveitems.readfrombuffer(buf) 2190 self.__field_items=LIST(**{'length': self.maxitems, 'elementclass': indexentry, 'createdefault': True}) 2191 self.__field_items.readfrombuffer(buf) 2192 self._bufferendoffset=buf.getcurrentoffset() 2193 2194 2195 def __getfield_maxitems(self): 2196 return self.__field_maxitems.getvalue() 2197 2198 def __setfield_maxitems(self, value): 2199 if isinstance(value,UINT): 2200 self.__field_maxitems=value 2201 else: 2202 self.__field_maxitems=UINT(value,**{'constant': 30}) 2203 2204 def __delfield_maxitems(self): del self.__field_maxitems 2205 2206 maxitems=property(__getfield_maxitems, __setfield_maxitems, __delfield_maxitems, None) 2207 2208 def __getfield_numactiveitems(self): 2209 return self.__field_numactiveitems.getvalue() 2210 2211 def __setfield_numactiveitems(self, value): 2212 if isinstance(value,UINT): 2213 self.__field_numactiveitems=value 2214 else: 2215 self.__field_numactiveitems=UINT(value,**{'sizeinbytes': 2}) 2216 2217 def __delfield_numactiveitems(self): del self.__field_numactiveitems 2218 2219 numactiveitems=property(__getfield_numactiveitems, __setfield_numactiveitems, __delfield_numactiveitems, None) 2220 2221 def __getfield_items(self): 2222 try: self.__field_items 2223 except: 2224 self.__field_items=LIST(**{'length': self.maxitems, 'elementclass': indexentry, 'createdefault': True}) 2225 return self.__field_items.getvalue() 2226 2227 def __setfield_items(self, value): 2228 if isinstance(value,LIST): 2229 self.__field_items=value 2230 else: 2231 self.__field_items=LIST(value,**{'length': self.maxitems, 'elementclass': indexentry, 'createdefault': True}) 2232 2233 def __delfield_items(self): del self.__field_items 2234 2235 items=property(__getfield_items, __setfield_items, __delfield_items, None) 2236 2237 def iscontainer(self): 2238 return True 2239 2240 def containerelements(self): 2241 yield ('maxitems', self.__field_maxitems, None) 2242 yield ('numactiveitems', self.__field_numactiveitems, None) 2243 yield ('items', self.__field_items, None) 2244 2245 2246 2247 2248 class scheduleexception(BaseProtogenClass): 2249 __fields=['pos', 'day', 'month', 'year'] 2250 2251 def __init__(self, *args, **kwargs): 2252 dict={} 2253 # What was supplied to this function 2254 dict.update(kwargs) 2255 # Parent constructor 2256 super(scheduleexception,self).__init__(**dict) 2257 if self.__class__ is scheduleexception: 2258 self._update(args,dict) 2259 2260 2261 def getfields(self): 2262 return self.__fields 2263 2264 2265 def _update(self, args, kwargs): 2266 super(scheduleexception,self)._update(args,kwargs) 2267 keys=kwargs.keys() 2268 for key in keys: 2269 if key in self.__fields: 2270 setattr(self, key, kwargs[key]) 2271 del kwargs[key] 2272 # Were any unrecognized kwargs passed in? 2273 if __debug__: 2274 self._complainaboutunusedargs(scheduleexception,kwargs) 2275 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 2276 # Make all P fields that haven't already been constructed 2277 2278 2279 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 2280 'Writes this packet to the supplied buffer' 2281 self._bufferstartoffset=buf.getcurrentoffset() 2282 self.__field_pos.writetobuffer(buf) 2283 self.__field_day.writetobuffer(buf) 2284 self.__field_month.writetobuffer(buf) 2285 self.__field_year.writetobuffer(buf) 2286 self._bufferendoffset=buf.getcurrentoffset() 2287 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 2288 2289 2290 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 2291 'Reads this packet from the supplied buffer' 2292 self._bufferstartoffset=buf.getcurrentoffset() 2293 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 2294 self.__field_pos=UINT(**{'sizeinbytes': 4}) 2295 self.__field_pos.readfrombuffer(buf) 2296 self.__field_day=UINT(**{'sizeinbytes': 1}) 2297 self.__field_day.readfrombuffer(buf) 2298 self.__field_month=UINT(**{'sizeinbytes': 1}) 2299 self.__field_month.readfrombuffer(buf) 2300 self.__field_year=UINT(**{'sizeinbytes': 2}) 2301 self.__field_year.readfrombuffer(buf) 2302 self._bufferendoffset=buf.getcurrentoffset() 2303 2304 2305 def __getfield_pos(self): 2306 return self.__field_pos.getvalue() 2307 2308 def __setfield_pos(self, value): 2309 if isinstance(value,UINT): 2310 self.__field_pos=value 2311 else: 2312 self.__field_pos=UINT(value,**{'sizeinbytes': 4}) 2313 2314 def __delfield_pos(self): del self.__field_pos 2315 2316 pos=property(__getfield_pos, __setfield_pos, __delfield_pos, "Refers to event id (position in schedule file) that this suppresses") 2317 2318 def __getfield_day(self): 2319 return self.__field_day.getvalue() 2320 2321 def __setfield_day(self, value): 2322 if isinstance(value,UINT): 2323 self.__field_day=value 2324 else: 2325 self.__field_day=UINT(value,**{'sizeinbytes': 1}) 2326 2327 def __delfield_day(self): del self.__field_day 2328 2329 day=property(__getfield_day, __setfield_day, __delfield_day, None) 2330 2331 def __getfield_month(self): 2332 return self.__field_month.getvalue() 2333 2334 def __setfield_month(self, value): 2335 if isinstance(value,UINT): 2336 self.__field_month=value 2337 else: 2338 self.__field_month=UINT(value,**{'sizeinbytes': 1}) 2339 2340 def __delfield_month(self): del self.__field_month 2341 2342 month=property(__getfield_month, __setfield_month, __delfield_month, None) 2343 2344 def __getfield_year(self): 2345 return self.__field_year.getvalue() 2346 2347 def __setfield_year(self, value): 2348 if isinstance(value,UINT): 2349 self.__field_year=value 2350 else: 2351 self.__field_year=UINT(value,**{'sizeinbytes': 2}) 2352 2353 def __delfield_year(self): del self.__field_year 2354 2355 year=property(__getfield_year, __setfield_year, __delfield_year, None) 2356 2357 def iscontainer(self): 2358 return True 2359 2360 def containerelements(self): 2361 yield ('pos', self.__field_pos, "Refers to event id (position in schedule file) that this suppresses") 2362 yield ('day', self.__field_day, None) 2363 yield ('month', self.__field_month, None) 2364 yield ('year', self.__field_year, None) 2365 2366 2367 2368 2369 class scheduleexceptionfile(BaseProtogenClass): 2370 __fields=['items'] 2371 2372 def __init__(self, *args, **kwargs): 2373 dict={} 2374 # What was supplied to this function 2375 dict.update(kwargs) 2376 # Parent constructor 2377 super(scheduleexceptionfile,self).__init__(**dict) 2378 if self.__class__ is scheduleexceptionfile: 2379 self._update(args,dict) 2380 2381 2382 def getfields(self): 2383 return self.__fields 2384 2385 2386 def _update(self, args, kwargs): 2387 super(scheduleexceptionfile,self)._update(args,kwargs) 2388 keys=kwargs.keys() 2389 for key in keys: 2390 if key in self.__fields: 2391 setattr(self, key, kwargs[key]) 2392 del kwargs[key] 2393 # Were any unrecognized kwargs passed in? 2394 if __debug__: 2395 self._complainaboutunusedargs(scheduleexceptionfile,kwargs) 2396 if len(args): 2397 dict2={'elementclass': scheduleexception} 2398 dict2.update(kwargs) 2399 kwargs=dict2 2400 self.__field_items=LIST(*args,**dict2) 2401 # Make all P fields that haven't already been constructed 2402 2403 2404 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 2405 'Writes this packet to the supplied buffer' 2406 self._bufferstartoffset=buf.getcurrentoffset() 2407 try: self.__field_items 2408 except: 2409 self.__field_items=LIST(**{'elementclass': scheduleexception}) 2410 self.__field_items.writetobuffer(buf) 2411 self._bufferendoffset=buf.getcurrentoffset() 2412 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 2413 2414 2415 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 2416 'Reads this packet from the supplied buffer' 2417 self._bufferstartoffset=buf.getcurrentoffset() 2418 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 2419 self.__field_items=LIST(**{'elementclass': scheduleexception}) 2420 self.__field_items.readfrombuffer(buf) 2421 self._bufferendoffset=buf.getcurrentoffset() 2422 2423 2424 def __getfield_items(self): 2425 try: self.__field_items 2426 except: 2427 self.__field_items=LIST(**{'elementclass': scheduleexception}) 2428 return self.__field_items.getvalue() 2429 2430 def __setfield_items(self, value): 2431 if isinstance(value,LIST): 2432 self.__field_items=value 2433 else: 2434 self.__field_items=LIST(value,**{'elementclass': scheduleexception}) 2435 2436 def __delfield_items(self): del self.__field_items 2437 2438 items=property(__getfield_items, __setfield_items, __delfield_items, None) 2439 2440 def iscontainer(self): 2441 return True 2442 2443 def containerelements(self): 2444 yield ('items', self.__field_items, None) 2445 2446 2447 2448 2449 class scheduleevent(BaseProtogenClass): 2450 __fields=['packet_size', 'pos', 'start', 'end', 'repeat', 'daybitmap', 'pad2', 'alarmminutes', 'alarmhours', 'alarmtype', 'snoozedelay', 'ringtone', 'description'] 2451 2452 def __init__(self, *args, **kwargs): 2453 dict={} 2454 # What was supplied to this function 2455 dict.update(kwargs) 2456 # Parent constructor 2457 super(scheduleevent,self).__init__(**dict) 2458 if self.__class__ is scheduleevent: 2459 self._update(args,dict) 2460 2461 2462 def getfields(self): 2463 return self.__fields 2464 2465 2466 def _update(self, args, kwargs): 2467 super(scheduleevent,self)._update(args,kwargs) 2468 keys=kwargs.keys() 2469 for key in keys: 2470 if key in self.__fields: 2471 setattr(self, key, kwargs[key]) 2472 del kwargs[key] 2473 # Were any unrecognized kwargs passed in? 2474 if __debug__: 2475 self._complainaboutunusedargs(scheduleevent,kwargs) 2476 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 2477 # Make all P fields that haven't already been constructed 2478 try: self.__field_packet_size 2479 except: 2480 self.__field_packet_size=UINT(**{ 'constant': 60 }) 2481 2482 2483 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 2484 'Writes this packet to the supplied buffer' 2485 self._bufferstartoffset=buf.getcurrentoffset() 2486 self.__field_pos.writetobuffer(buf) 2487 self.__field_start.writetobuffer(buf) 2488 self.__field_end.writetobuffer(buf) 2489 self.__field_repeat.writetobuffer(buf) 2490 self.__field_daybitmap.writetobuffer(buf) 2491 try: self.__field_pad2 2492 except: 2493 self.__field_pad2=UINT(**{'sizeinbytes': 1, 'default': 0 }) 2494 self.__field_pad2.writetobuffer(buf) 2495 self.__field_alarmminutes.writetobuffer(buf) 2496 self.__field_alarmhours.writetobuffer(buf) 2497 self.__field_alarmtype.writetobuffer(buf) 2498 try: self.__field_snoozedelay 2499 except: 2500 self.__field_snoozedelay=UINT(**{'sizeinbytes': 1, 'default': 0 }) 2501 self.__field_snoozedelay.writetobuffer(buf) 2502 self.__field_ringtone.writetobuffer(buf) 2503 self.__field_description.writetobuffer(buf) 2504 self._bufferendoffset=buf.getcurrentoffset() 2505 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 2506 2507 2508 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 2509 'Reads this packet from the supplied buffer' 2510 self._bufferstartoffset=buf.getcurrentoffset() 2511 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 2512 self.__field_pos=UINT(**{'sizeinbytes': 4}) 2513 self.__field_pos.readfrombuffer(buf) 2514 self.__field_start=LGCALDATE(**{'sizeinbytes': 4}) 2515 self.__field_start.readfrombuffer(buf) 2516 self.__field_end=LGCALDATE(**{'sizeinbytes': 4}) 2517 self.__field_end.readfrombuffer(buf) 2518 self.__field_repeat=UINT(**{'sizeinbytes': 1}) 2519 self.__field_repeat.readfrombuffer(buf) 2520 self.__field_daybitmap=UINT(**{'sizeinbytes': 2}) 2521 self.__field_daybitmap.readfrombuffer(buf) 2522 self.__field_pad2=UINT(**{'sizeinbytes': 1, 'default': 0 }) 2523 self.__field_pad2.readfrombuffer(buf) 2524 self.__field_alarmminutes=UINT(**{'sizeinbytes': 1}) 2525 self.__field_alarmminutes.readfrombuffer(buf) 2526 self.__field_alarmhours=UINT(**{'sizeinbytes': 1}) 2527 self.__field_alarmhours.readfrombuffer(buf) 2528 self.__field_alarmtype=UINT(**{'sizeinbytes': 1}) 2529 self.__field_alarmtype.readfrombuffer(buf) 2530 self.__field_snoozedelay=UINT(**{'sizeinbytes': 1, 'default': 0 }) 2531 self.__field_snoozedelay.readfrombuffer(buf) 2532 self.__field_ringtone=UINT(**{'sizeinbytes': 1}) 2533 self.__field_ringtone.readfrombuffer(buf) 2534 self.__field_description=USTRING(**{'sizeinbytes': 39, 'raiseontruncate': False }) 2535 self.__field_description.readfrombuffer(buf) 2536 self._bufferendoffset=buf.getcurrentoffset() 2537 2538 2539 def __getfield_packet_size(self): 2540 return self.__field_packet_size.getvalue() 2541 2542 def __setfield_packet_size(self, value): 2543 if isinstance(value,UINT): 2544 self.__field_packet_size=value 2545 else: 2546 self.__field_packet_size=UINT(value,**{ 'constant': 60 }) 2547 2548 def __delfield_packet_size(self): del self.__field_packet_size 2549 2550 packet_size=property(__getfield_packet_size, __setfield_packet_size, __delfield_packet_size, "Faster than packetsize()") 2551 2552 def __getfield_pos(self): 2553 return self.__field_pos.getvalue() 2554 2555 def __setfield_pos(self, value): 2556 if isinstance(value,UINT): 2557 self.__field_pos=value 2558 else: 2559 self.__field_pos=UINT(value,**{'sizeinbytes': 4}) 2560 2561 def __delfield_pos(self): del self.__field_pos 2562 2563 pos=property(__getfield_pos, __setfield_pos, __delfield_pos, "position within file, used as an event id") 2564 2565 def __getfield_start(self): 2566 return self.__field_start.getvalue() 2567 2568 def __setfield_start(self, value): 2569 if isinstance(value,LGCALDATE): 2570 self.__field_start=value 2571 else: 2572 self.__field_start=LGCALDATE(value,**{'sizeinbytes': 4}) 2573 2574 def __delfield_start(self): del self.__field_start 2575 2576 start=property(__getfield_start, __setfield_start, __delfield_start, None) 2577 2578 def __getfield_end(self): 2579 return self.__field_end.getvalue() 2580 2581 def __setfield_end(self, value): 2582 if isinstance(value,LGCALDATE): 2583 self.__field_end=value 2584 else: 2585 self.__field_end=LGCALDATE(value,**{'sizeinbytes': 4}) 2586 2587 def __delfield_end(self): del self.__field_end 2588 2589 end=property(__getfield_end, __setfield_end, __delfield_end, None) 2590 2591 def __getfield_repeat(self): 2592 return self.__field_repeat.getvalue() 2593 2594 def __setfield_repeat(self, value): 2595 if isinstance(value,UINT): 2596 self.__field_repeat=value 2597 else: 2598 self.__field_repeat=UINT(value,**{'sizeinbytes': 1}) 2599 2600 def __delfield_repeat(self): del self.__field_repeat 2601 2602 repeat=property(__getfield_repeat, __setfield_repeat, __delfield_repeat, None) 2603 2604 def __getfield_daybitmap(self): 2605 return self.__field_daybitmap.getvalue() 2606 2607 def __setfield_daybitmap(self, value): 2608 if isinstance(value,UINT): 2609 self.__field_daybitmap=value 2610 else: 2611 self.__field_daybitmap=UINT(value,**{'sizeinbytes': 2}) 2612 2613 def __delfield_daybitmap(self): del self.__field_daybitmap 2614 2615 daybitmap=property(__getfield_daybitmap, __setfield_daybitmap, __delfield_daybitmap, "which days a weekly repeat event happens on") 2616 2617 def __getfield_pad2(self): 2618 try: self.__field_pad2 2619 except: 2620 self.__field_pad2=UINT(**{'sizeinbytes': 1, 'default': 0 }) 2621 return self.__field_pad2.getvalue() 2622 2623 def __setfield_pad2(self, value): 2624 if isinstance(value,UINT): 2625 self.__field_pad2=value 2626 else: 2627 self.__field_pad2=UINT(value,**{'sizeinbytes': 1, 'default': 0 }) 2628 2629 def __delfield_pad2(self): del self.__field_pad2 2630 2631 pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None) 2632 2633 def __getfield_alarmminutes(self): 2634 return self.__field_alarmminutes.getvalue() 2635 2636 def __setfield_alarmminutes(self, value): 2637 if isinstance(value,UINT): 2638 self.__field_alarmminutes=value 2639 else: 2640 self.__field_alarmminutes=UINT(value,**{'sizeinbytes': 1}) 2641 2642 def __delfield_alarmminutes(self): del self.__field_alarmminutes 2643 2644 alarmminutes=property(__getfield_alarmminutes, __setfield_alarmminutes, __delfield_alarmminutes, "a value of 100 indicates not set") 2645 2646 def __getfield_alarmhours(self): 2647 return self.__field_alarmhours.getvalue() 2648 2649 def __setfield_alarmhours(self, value): 2650 if isinstance(value,UINT): 2651 self.__field_alarmhours=value 2652 else: 2653 self.__field_alarmhours=UINT(value,**{'sizeinbytes': 1}) 2654 2655 def __delfield_alarmhours(self): del self.__field_alarmhours 2656 2657 alarmhours=property(__getfield_alarmhours, __setfield_alarmhours, __delfield_alarmhours, "a value of 100 indicates not set") 2658 2659 def __getfield_alarmtype(self): 2660 return self.__field_alarmtype.getvalue() 2661 2662 def __setfield_alarmtype(self, value): 2663 if isinstance(value,UINT): 2664 self.__field_alarmtype=value 2665 else: 2666 self.__field_alarmtype=UINT(value,**{'sizeinbytes': 1}) 2667 2668 def __delfield_alarmtype(self): del self.__field_alarmtype 2669 2670 alarmtype=property(__getfield_alarmtype, __setfield_alarmtype, __delfield_alarmtype, "preset alarm reminder type") 2671 2672 def __getfield_snoozedelay(self): 2673 try: self.__field_snoozedelay 2674 except: 2675 self.__field_snoozedelay=UINT(**{'sizeinbytes': 1, 'default': 0 }) 2676 return self.__field_snoozedelay.getvalue() 2677 2678 def __setfield_snoozedelay(self, value): 2679 if isinstance(value,UINT): 2680 self.__field_snoozedelay=value 2681 else: 2682 self.__field_snoozedelay=UINT(value,**{'sizeinbytes': 1, 'default': 0 }) 2683 2684 def __delfield_snoozedelay(self): del self.__field_snoozedelay 2685 2686 snoozedelay=property(__getfield_snoozedelay, __setfield_snoozedelay, __delfield_snoozedelay, "in minutes, not for this phone") 2687 2688 def __getfield_ringtone(self): 2689 return self.__field_ringtone.getvalue() 2690 2691 def __setfield_ringtone(self, value): 2692 if isinstance(value,UINT): 2693 self.__field_ringtone=value 2694 else: 2695 self.__field_ringtone=UINT(value,**{'sizeinbytes': 1}) 2696 2697 def __delfield_ringtone(self): del self.__field_ringtone 2698 2699 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 2700 2701 def __getfield_description(self): 2702 return self.__field_description.getvalue() 2703 2704 def __setfield_description(self, value): 2705 if isinstance(value,USTRING): 2706 self.__field_description=value 2707 else: 2708 self.__field_description=USTRING(value,**{'sizeinbytes': 39, 'raiseontruncate': False }) 2709 2710 def __delfield_description(self): del self.__field_description 2711 2712 description=property(__getfield_description, __setfield_description, __delfield_description, None) 2713 2714 def iscontainer(self): 2715 return True 2716 2717 def containerelements(self): 2718 yield ('packet_size', self.__field_packet_size, "Faster than packetsize()") 2719 yield ('pos', self.__field_pos, "position within file, used as an event id") 2720 yield ('start', self.__field_start, None) 2721 yield ('end', self.__field_end, None) 2722 yield ('repeat', self.__field_repeat, None) 2723 yield ('daybitmap', self.__field_daybitmap, "which days a weekly repeat event happens on") 2724 yield ('pad2', self.__field_pad2, None) 2725 yield ('alarmminutes', self.__field_alarmminutes, "a value of 100 indicates not set") 2726 yield ('alarmhours', self.__field_alarmhours, "a value of 100 indicates not set") 2727 yield ('alarmtype', self.__field_alarmtype, "preset alarm reminder type") 2728 yield ('snoozedelay', self.__field_snoozedelay, "in minutes, not for this phone") 2729 yield ('ringtone', self.__field_ringtone, None) 2730 yield ('description', self.__field_description, None) 2731 2732 2733 2734 2735 class schedulefile(BaseProtogenClass): 2736 __fields=['numactiveitems', 'events'] 2737 2738 def __init__(self, *args, **kwargs): 2739 dict={} 2740 # What was supplied to this function 2741 dict.update(kwargs) 2742 # Parent constructor 2743 super(schedulefile,self).__init__(**dict) 2744 if self.__class__ is schedulefile: 2745 self._update(args,dict) 2746 2747 2748 def getfields(self): 2749 return self.__fields 2750 2751 2752 def _update(self, args, kwargs): 2753 super(schedulefile,self)._update(args,kwargs) 2754 keys=kwargs.keys() 2755 for key in keys: 2756 if key in self.__fields: 2757 setattr(self, key, kwargs[key]) 2758 del kwargs[key] 2759 # Were any unrecognized kwargs passed in? 2760 if __debug__: 2761 self._complainaboutunusedargs(schedulefile,kwargs) 2762 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 2763 # Make all P fields that haven't already been constructed 2764 2765 2766 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 2767 'Writes this packet to the supplied buffer' 2768 self._bufferstartoffset=buf.getcurrentoffset() 2769 self.__field_numactiveitems.writetobuffer(buf) 2770 try: self.__field_events 2771 except: 2772 self.__field_events=LIST(**{'elementclass': scheduleevent}) 2773 self.__field_events.writetobuffer(buf) 2774 self._bufferendoffset=buf.getcurrentoffset() 2775 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 2776 2777 2778 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 2779 'Reads this packet from the supplied buffer' 2780 self._bufferstartoffset=buf.getcurrentoffset() 2781 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 2782 self.__field_numactiveitems=UINT(**{'sizeinbytes': 2}) 2783 self.__field_numactiveitems.readfrombuffer(buf) 2784 self.__field_events=LIST(**{'elementclass': scheduleevent}) 2785 self.__field_events.readfrombuffer(buf) 2786 self._bufferendoffset=buf.getcurrentoffset() 2787 2788 2789 def __getfield_numactiveitems(self): 2790 return self.__field_numactiveitems.getvalue() 2791 2792 def __setfield_numactiveitems(self, value): 2793 if isinstance(value,UINT): 2794 self.__field_numactiveitems=value 2795 else: 2796 self.__field_numactiveitems=UINT(value,**{'sizeinbytes': 2}) 2797 2798 def __delfield_numactiveitems(self): del self.__field_numactiveitems 2799 2800 numactiveitems=property(__getfield_numactiveitems, __setfield_numactiveitems, __delfield_numactiveitems, None) 2801 2802 def __getfield_events(self): 2803 try: self.__field_events 2804 except: 2805 self.__field_events=LIST(**{'elementclass': scheduleevent}) 2806 return self.__field_events.getvalue() 2807 2808 def __setfield_events(self, value): 2809 if isinstance(value,LIST): 2810 self.__field_events=value 2811 else: 2812 self.__field_events=LIST(value,**{'elementclass': scheduleevent}) 2813 2814 def __delfield_events(self): del self.__field_events 2815 2816 events=property(__getfield_events, __setfield_events, __delfield_events, None) 2817 2818 def iscontainer(self): 2819 return True 2820 2821 def containerelements(self): 2822 yield ('numactiveitems', self.__field_numactiveitems, None) 2823 yield ('events', self.__field_events, None) 2824 2825 2826 2827 2828 class call(BaseProtogenClass): 2829 __fields=['GPStime', 'unknown1', 'duration', 'number', 'name', 'numberlength', 'unknown2', 'pbnumbertype', 'unknown3', 'pbentrynum'] 2830 2831 def __init__(self, *args, **kwargs): 2832 dict={} 2833 # What was supplied to this function 2834 dict.update(kwargs) 2835 # Parent constructor 2836 super(call,self).__init__(**dict) 2837 if self.__class__ is call: 2838 self._update(args,dict) 2839 2840 2841 def getfields(self): 2842 return self.__fields 2843 2844 2845 def _update(self, args, kwargs): 2846 super(call,self)._update(args,kwargs) 2847 keys=kwargs.keys() 2848 for key in keys: 2849 if key in self.__fields: 2850 setattr(self, key, kwargs[key]) 2851 del kwargs[key] 2852 # Were any unrecognized kwargs passed in? 2853 if __debug__: 2854 self._complainaboutunusedargs(call,kwargs) 2855 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 2856 # Make all P fields that haven't already been constructed 2857 2858 2859 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 2860 'Writes this packet to the supplied buffer' 2861 self._bufferstartoffset=buf.getcurrentoffset() 2862 self.__field_GPStime.writetobuffer(buf) 2863 self.__field_unknown1.writetobuffer(buf) 2864 self.__field_duration.writetobuffer(buf) 2865 self.__field_number.writetobuffer(buf) 2866 self.__field_name.writetobuffer(buf) 2867 self.__field_numberlength.writetobuffer(buf) 2868 self.__field_unknown2.writetobuffer(buf) 2869 self.__field_pbnumbertype.writetobuffer(buf) 2870 self.__field_unknown3.writetobuffer(buf) 2871 self.__field_pbentrynum.writetobuffer(buf) 2872 self._bufferendoffset=buf.getcurrentoffset() 2873 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 2874 2875 2876 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 2877 'Reads this packet from the supplied buffer' 2878 self._bufferstartoffset=buf.getcurrentoffset() 2879 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 2880 self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4}) 2881 self.__field_GPStime.readfrombuffer(buf) 2882 self.__field_unknown1=UINT(**{'sizeinbytes': 4}) 2883 self.__field_unknown1.readfrombuffer(buf) 2884 self.__field_duration=UINT(**{'sizeinbytes': 4}) 2885 self.__field_duration.readfrombuffer(buf) 2886 self.__field_number=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 2887 self.__field_number.readfrombuffer(buf) 2888 self.__field_name=USTRING(**{'sizeinbytes': 36, 'raiseonunterminatedread': False}) 2889 self.__field_name.readfrombuffer(buf) 2890 self.__field_numberlength=UINT(**{'sizeinbytes': 1}) 2891 self.__field_numberlength.readfrombuffer(buf) 2892 self.__field_unknown2=UINT(**{'sizeinbytes': 1}) 2893 self.__field_unknown2.readfrombuffer(buf) 2894 self.__field_pbnumbertype=UINT(**{'sizeinbytes': 1}) 2895 self.__field_pbnumbertype.readfrombuffer(buf) 2896 self.__field_unknown3=UINT(**{'sizeinbytes': 2}) 2897 self.__field_unknown3.readfrombuffer(buf) 2898 self.__field_pbentrynum=UINT(**{'sizeinbytes': 1}) 2899 self.__field_pbentrynum.readfrombuffer(buf) 2900 self._bufferendoffset=buf.getcurrentoffset() 2901 2902 2903 def __getfield_GPStime(self): 2904 return self.__field_GPStime.getvalue() 2905 2906 def __setfield_GPStime(self, value): 2907 if isinstance(value,GPSDATE): 2908 self.__field_GPStime=value 2909 else: 2910 self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4}) 2911 2912 def __delfield_GPStime(self): del self.__field_GPStime 2913 2914 GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None) 2915 2916 def __getfield_unknown1(self): 2917 return self.__field_unknown1.getvalue() 2918 2919 def __setfield_unknown1(self, value): 2920 if isinstance(value,UINT): 2921 self.__field_unknown1=value 2922 else: 2923 self.__field_unknown1=UINT(value,**{'sizeinbytes': 4}) 2924 2925 def __delfield_unknown1(self): del self.__field_unknown1 2926 2927 unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 2928 2929 def __getfield_duration(self): 2930 return self.__field_duration.getvalue() 2931 2932 def __setfield_duration(self, value): 2933 if isinstance(value,UINT): 2934 self.__field_duration=value 2935 else: 2936 self.__field_duration=UINT(value,**{'sizeinbytes': 4}) 2937 2938 def __delfield_duration(self): del self.__field_duration 2939 2940 duration=property(__getfield_duration, __setfield_duration, __delfield_duration, None) 2941 2942 def __getfield_number(self): 2943 return self.__field_number.getvalue() 2944 2945 def __setfield_number(self, value): 2946 if isinstance(value,USTRING): 2947 self.__field_number=value 2948 else: 2949 self.__field_number=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 2950 2951 def __delfield_number(self): del self.__field_number 2952 2953 number=property(__getfield_number, __setfield_number, __delfield_number, None) 2954 2955 def __getfield_name(self): 2956 return self.__field_name.getvalue() 2957 2958 def __setfield_name(self, value): 2959 if isinstance(value,USTRING): 2960 self.__field_name=value 2961 else: 2962 self.__field_name=USTRING(value,**{'sizeinbytes': 36, 'raiseonunterminatedread': False}) 2963 2964 def __delfield_name(self): del self.__field_name 2965 2966 name=property(__getfield_name, __setfield_name, __delfield_name, None) 2967 2968 def __getfield_numberlength(self): 2969 return self.__field_numberlength.getvalue() 2970 2971 def __setfield_numberlength(self, value): 2972 if isinstance(value,UINT): 2973 self.__field_numberlength=value 2974 else: 2975 self.__field_numberlength=UINT(value,**{'sizeinbytes': 1}) 2976 2977 def __delfield_numberlength(self): del self.__field_numberlength 2978 2979 numberlength=property(__getfield_numberlength, __setfield_numberlength, __delfield_numberlength, None) 2980 2981 def __getfield_unknown2(self): 2982 return self.__field_unknown2.getvalue() 2983 2984 def __setfield_unknown2(self, value): 2985 if isinstance(value,UINT): 2986 self.__field_unknown2=value 2987 else: 2988 self.__field_unknown2=UINT(value,**{'sizeinbytes': 1}) 2989 2990 def __delfield_unknown2(self): del self.__field_unknown2 2991 2992 unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None) 2993 2994 def __getfield_pbnumbertype(self): 2995 return self.__field_pbnumbertype.getvalue() 2996 2997 def __setfield_pbnumbertype(self, value): 2998 if isinstance(value,UINT): 2999 self.__field_pbnumbertype=value 3000 else: 3001 self.__field_pbnumbertype=UINT(value,**{'sizeinbytes': 1}) 3002 3003 def __delfield_pbnumbertype(self): del self.__field_pbnumbertype 3004 3005 pbnumbertype=property(__getfield_pbnumbertype, __setfield_pbnumbertype, __delfield_pbnumbertype, None) 3006 3007 def __getfield_unknown3(self): 3008 return self.__field_unknown3.getvalue() 3009 3010 def __setfield_unknown3(self, value): 3011 if isinstance(value,UINT): 3012 self.__field_unknown3=value 3013 else: 3014 self.__field_unknown3=UINT(value,**{'sizeinbytes': 2}) 3015 3016 def __delfield_unknown3(self): del self.__field_unknown3 3017 3018 unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None) 3019 3020 def __getfield_pbentrynum(self): 3021 return self.__field_pbentrynum.getvalue() 3022 3023 def __setfield_pbentrynum(self, value): 3024 if isinstance(value,UINT): 3025 self.__field_pbentrynum=value 3026 else: 3027 self.__field_pbentrynum=UINT(value,**{'sizeinbytes': 1}) 3028 3029 def __delfield_pbentrynum(self): del self.__field_pbentrynum 3030 3031 pbentrynum=property(__getfield_pbentrynum, __setfield_pbentrynum, __delfield_pbentrynum, None) 3032 3033 def iscontainer(self): 3034 return True 3035 3036 def containerelements(self): 3037 yield ('GPStime', self.__field_GPStime, None) 3038 yield ('unknown1', self.__field_unknown1, None) 3039 yield ('duration', self.__field_duration, None) 3040 yield ('number', self.__field_number, None) 3041 yield ('name', self.__field_name, None) 3042 yield ('numberlength', self.__field_numberlength, None) 3043 yield ('unknown2', self.__field_unknown2, None) 3044 yield ('pbnumbertype', self.__field_pbnumbertype, None) 3045 yield ('unknown3', self.__field_unknown3, None) 3046 yield ('pbentrynum', self.__field_pbentrynum, None) 3047 3048 3049 3050 3051 class callhistory(BaseProtogenClass): 3052 __fields=['numcalls', 'unknown1', 'calls'] 3053 3054 def __init__(self, *args, **kwargs): 3055 dict={} 3056 # What was supplied to this function 3057 dict.update(kwargs) 3058 # Parent constructor 3059 super(callhistory,self).__init__(**dict) 3060 if self.__class__ is callhistory: 3061 self._update(args,dict) 3062 3063 3064 def getfields(self): 3065 return self.__fields 3066 3067 3068 def _update(self, args, kwargs): 3069 super(callhistory,self)._update(args,kwargs) 3070 keys=kwargs.keys() 3071 for key in keys: 3072 if key in self.__fields: 3073 setattr(self, key, kwargs[key]) 3074 del kwargs[key] 3075 # Were any unrecognized kwargs passed in? 3076 if __debug__: 3077 self._complainaboutunusedargs(callhistory,kwargs) 3078 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 3079 # Make all P fields that haven't already been constructed 3080 3081 3082 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 3083 'Writes this packet to the supplied buffer' 3084 self._bufferstartoffset=buf.getcurrentoffset() 3085 self.__field_numcalls.writetobuffer(buf) 3086 self.__field_unknown1.writetobuffer(buf) 3087 try: self.__field_calls 3088 except: 3089 self.__field_calls=LIST(**{'elementclass': call}) 3090 self.__field_calls.writetobuffer(buf) 3091 self._bufferendoffset=buf.getcurrentoffset() 3092 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 3093 3094 3095 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 3096 'Reads this packet from the supplied buffer' 3097 self._bufferstartoffset=buf.getcurrentoffset() 3098 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 3099 self.__field_numcalls=UINT(**{'sizeinbytes': 4}) 3100 self.__field_numcalls.readfrombuffer(buf) 3101 self.__field_unknown1=UINT(**{'sizeinbytes': 1}) 3102 self.__field_unknown1.readfrombuffer(buf) 3103 self.__field_calls=LIST(**{'elementclass': call}) 3104 self.__field_calls.readfrombuffer(buf) 3105 self._bufferendoffset=buf.getcurrentoffset() 3106 3107 3108 def __getfield_numcalls(self): 3109 return self.__field_numcalls.getvalue() 3110 3111 def __setfield_numcalls(self, value): 3112 if isinstance(value,UINT): 3113 self.__field_numcalls=value 3114 else: 3115 self.__field_numcalls=UINT(value,**{'sizeinbytes': 4}) 3116 3117 def __delfield_numcalls(self): del self.__field_numcalls 3118 3119 numcalls=property(__getfield_numcalls, __setfield_numcalls, __delfield_numcalls, None) 3120 3121 def __getfield_unknown1(self): 3122 return self.__field_unknown1.getvalue() 3123 3124 def __setfield_unknown1(self, value): 3125 if isinstance(value,UINT): 3126 self.__field_unknown1=value 3127 else: 3128 self.__field_unknown1=UINT(value,**{'sizeinbytes': 1}) 3129 3130 def __delfield_unknown1(self): del self.__field_unknown1 3131 3132 unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 3133 3134 def __getfield_calls(self): 3135 try: self.__field_calls 3136 except: 3137 self.__field_calls=LIST(**{'elementclass': call}) 3138 return self.__field_calls.getvalue() 3139 3140 def __setfield_calls(self, value): 3141 if isinstance(value,LIST): 3142 self.__field_calls=value 3143 else: 3144 self.__field_calls=LIST(value,**{'elementclass': call}) 3145 3146 def __delfield_calls(self): del self.__field_calls 3147 3148 calls=property(__getfield_calls, __setfield_calls, __delfield_calls, None) 3149 3150 def iscontainer(self): 3151 return True 3152 3153 def containerelements(self): 3154 yield ('numcalls', self.__field_numcalls, None) 3155 yield ('unknown1', self.__field_unknown1, None) 3156 yield ('calls', self.__field_calls, None) 3157 3158 3159 3160 3161 class msg_record(BaseProtogenClass): 3162 __fields=['unknown1', 'binary', 'unknown3', 'unknown4', 'unknown6', 'length', 'msg'] 3163 3164 def __init__(self, *args, **kwargs): 3165 dict={} 3166 # What was supplied to this function 3167 dict.update(kwargs) 3168 # Parent constructor 3169 super(msg_record,self).__init__(**dict) 3170 if self.__class__ is msg_record: 3171 self._update(args,dict) 3172 3173 3174 def getfields(self): 3175 return self.__fields 3176 3177 3178 def _update(self, args, kwargs): 3179 super(msg_record,self)._update(args,kwargs) 3180 keys=kwargs.keys() 3181 for key in keys: 3182 if key in self.__fields: 3183 setattr(self, key, kwargs[key]) 3184 del kwargs[key] 3185 # Were any unrecognized kwargs passed in? 3186 if __debug__: 3187 self._complainaboutunusedargs(msg_record,kwargs) 3188 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 3189 # Make all P fields that haven't already been constructed 3190 3191 3192 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 3193 'Writes this packet to the supplied buffer' 3194 self._bufferstartoffset=buf.getcurrentoffset() 3195 self.__field_unknown1.writetobuffer(buf) 3196 self.__field_binary.writetobuffer(buf) 3197 self.__field_unknown3.writetobuffer(buf) 3198 self.__field_unknown4.writetobuffer(buf) 3199 self.__field_unknown6.writetobuffer(buf) 3200 self.__field_length.writetobuffer(buf) 3201 try: self.__field_msg 3202 except: 3203 self.__field_msg=LIST(**{'elementclass': _gen_p_lgvi125_290, 'length': 219}) 3204 self.__field_msg.writetobuffer(buf) 3205 self._bufferendoffset=buf.getcurrentoffset() 3206 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 3207 3208 3209 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 3210 'Reads this packet from the supplied buffer' 3211 self._bufferstartoffset=buf.getcurrentoffset() 3212 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 3213 self.__field_unknown1=UINT(**{'sizeinbytes': 1}) 3214 self.__field_unknown1.readfrombuffer(buf) 3215 self.__field_binary=UINT(**{'sizeinbytes': 1}) 3216 self.__field_binary.readfrombuffer(buf) 3217 self.__field_unknown3=UINT(**{'sizeinbytes': 1}) 3218 self.__field_unknown3.readfrombuffer(buf) 3219 self.__field_unknown4=UINT(**{'sizeinbytes': 1}) 3220 self.__field_unknown4.readfrombuffer(buf) 3221 self.__field_unknown6=UINT(**{'sizeinbytes': 1}) 3222 self.__field_unknown6.readfrombuffer(buf) 3223 self.__field_length=UINT(**{'sizeinbytes': 1}) 3224 self.__field_length.readfrombuffer(buf) 3225 self.__field_msg=LIST(**{'elementclass': _gen_p_lgvi125_290, 'length': 219}) 3226 self.__field_msg.readfrombuffer(buf) 3227 self._bufferendoffset=buf.getcurrentoffset() 3228 3229 3230 def __getfield_unknown1(self): 3231 return self.__field_unknown1.getvalue() 3232 3233 def __setfield_unknown1(self, value): 3234 if isinstance(value,UINT): 3235 self.__field_unknown1=value 3236 else: 3237 self.__field_unknown1=UINT(value,**{'sizeinbytes': 1}) 3238 3239 def __delfield_unknown1(self): del self.__field_unknown1 3240 3241 unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 3242 3243 def __getfield_binary(self): 3244 return self.__field_binary.getvalue() 3245 3246 def __setfield_binary(self, value): 3247 if isinstance(value,UINT): 3248 self.__field_binary=value 3249 else: 3250 self.__field_binary=UINT(value,**{'sizeinbytes': 1}) 3251 3252 def __delfield_binary(self): del self.__field_binary 3253 3254 binary=property(__getfield_binary, __setfield_binary, __delfield_binary, None) 3255 3256 def __getfield_unknown3(self): 3257 return self.__field_unknown3.getvalue() 3258 3259 def __setfield_unknown3(self, value): 3260 if isinstance(value,UINT): 3261 self.__field_unknown3=value 3262 else: 3263 self.__field_unknown3=UINT(value,**{'sizeinbytes': 1}) 3264 3265 def __delfield_unknown3(self): del self.__field_unknown3 3266 3267 unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None) 3268 3269 def __getfield_unknown4(self): 3270 return self.__field_unknown4.getvalue() 3271 3272 def __setfield_unknown4(self, value): 3273 if isinstance(value,UINT): 3274 self.__field_unknown4=value 3275 else: 3276 self.__field_unknown4=UINT(value,**{'sizeinbytes': 1}) 3277 3278 def __delfield_unknown4(self): del self.__field_unknown4 3279 3280 unknown4=property(__getfield_unknown4, __setfield_unknown4, __delfield_unknown4, None) 3281 3282 def __getfield_unknown6(self): 3283 return self.__field_unknown6.getvalue() 3284 3285 def __setfield_unknown6(self, value): 3286 if isinstance(value,UINT): 3287 self.__field_unknown6=value 3288 else: 3289 self.__field_unknown6=UINT(value,**{'sizeinbytes': 1}) 3290 3291 def __delfield_unknown6(self): del self.__field_unknown6 3292 3293 unknown6=property(__getfield_unknown6, __setfield_unknown6, __delfield_unknown6, None) 3294 3295 def __getfield_length(self): 3296 return self.__field_length.getvalue() 3297 3298 def __setfield_length(self, value): 3299 if isinstance(value,UINT): 3300 self.__field_length=value 3301 else: 3302 self.__field_length=UINT(value,**{'sizeinbytes': 1}) 3303 3304 def __delfield_length(self): del self.__field_length 3305 3306 length=property(__getfield_length, __setfield_length, __delfield_length, None) 3307 3308 def __getfield_msg(self): 3309 try: self.__field_msg 3310 except: 3311 self.__field_msg=LIST(**{'elementclass': _gen_p_lgvi125_290, 'length': 219}) 3312 return self.__field_msg.getvalue() 3313 3314 def __setfield_msg(self, value): 3315 if isinstance(value,LIST): 3316 self.__field_msg=value 3317 else: 3318 self.__field_msg=LIST(value,**{'elementclass': _gen_p_lgvi125_290, 'length': 219}) 3319 3320 def __delfield_msg(self): del self.__field_msg 3321 3322 msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None) 3323 3324 def iscontainer(self): 3325 return True 3326 3327 def containerelements(self): 3328 yield ('unknown1', self.__field_unknown1, None) 3329 yield ('binary', self.__field_binary, None) 3330 yield ('unknown3', self.__field_unknown3, None) 3331 yield ('unknown4', self.__field_unknown4, None) 3332 yield ('unknown6', self.__field_unknown6, None) 3333 yield ('length', self.__field_length, None) 3334 yield ('msg', self.__field_msg, None) 3335 3336 3337 3338 3339 class _gen_p_lgvi125_290(BaseProtogenClass): 3340 'Anonymous inner class' 3341 __fields=['byte'] 3342 3343 def __init__(self, *args, **kwargs): 3344 dict={} 3345 # What was supplied to this function 3346 dict.update(kwargs) 3347 # Parent constructor 3348 super(_gen_p_lgvi125_290,self).__init__(**dict) 3349 if self.__class__ is _gen_p_lgvi125_290: 3350 self._update(args,dict) 3351 3352 3353 def getfields(self): 3354 return self.__fields 3355 3356 3357 def _update(self, args, kwargs): 3358 super(_gen_p_lgvi125_290,self)._update(args,kwargs) 3359 keys=kwargs.keys() 3360 for key in keys: 3361 if key in self.__fields: 3362 setattr(self, key, kwargs[key]) 3363 del kwargs[key] 3364 # Were any unrecognized kwargs passed in? 3365 if __debug__: 3366 self._complainaboutunusedargs(_gen_p_lgvi125_290,kwargs) 3367 if len(args): 3368 dict2={'sizeinbytes': 1} 3369 dict2.update(kwargs) 3370 kwargs=dict2 3371 self.__field_byte=UINT(*args,**dict2) 3372 # Make all P fields that haven't already been constructed 3373 3374 3375 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 3376 'Writes this packet to the supplied buffer' 3377 self._bufferstartoffset=buf.getcurrentoffset() 3378 self.__field_byte.writetobuffer(buf) 3379 self._bufferendoffset=buf.getcurrentoffset() 3380 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 3381 3382 3383 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 3384 'Reads this packet from the supplied buffer' 3385 self._bufferstartoffset=buf.getcurrentoffset() 3386 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 3387 self.__field_byte=UINT(**{'sizeinbytes': 1}) 3388 self.__field_byte.readfrombuffer(buf) 3389 self._bufferendoffset=buf.getcurrentoffset() 3390 3391 3392 def __getfield_byte(self): 3393 return self.__field_byte.getvalue() 3394 3395 def __setfield_byte(self, value): 3396 if isinstance(value,UINT): 3397 self.__field_byte=value 3398 else: 3399 self.__field_byte=UINT(value,**{'sizeinbytes': 1}) 3400 3401 def __delfield_byte(self): del self.__field_byte 3402 3403 byte=property(__getfield_byte, __setfield_byte, __delfield_byte, "individual byte of message") 3404 3405 def iscontainer(self): 3406 return True 3407 3408 def containerelements(self): 3409 yield ('byte', self.__field_byte, "individual byte of message") 3410 3411 3412 3413 3414 class recipient_record(BaseProtogenClass): 3415 __fields=['unknown1', 'number', 'status', 'timesent', 'timereceived', 'unknown2'] 3416 3417 def __init__(self, *args, **kwargs): 3418 dict={} 3419 # What was supplied to this function 3420 dict.update(kwargs) 3421 # Parent constructor 3422 super(recipient_record,self).__init__(**dict) 3423 if self.__class__ is recipient_record: 3424 self._update(args,dict) 3425 3426 3427 def getfields(self): 3428 return self.__fields 3429 3430 3431 def _update(self, args, kwargs): 3432 super(recipient_record,self)._update(args,kwargs) 3433 keys=kwargs.keys() 3434 for key in keys: 3435 if key in self.__fields: 3436 setattr(self, key, kwargs[key]) 3437 del kwargs[key] 3438 # Were any unrecognized kwargs passed in? 3439 if __debug__: 3440 self._complainaboutunusedargs(recipient_record,kwargs) 3441 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 3442 # Make all P fields that haven't already been constructed 3443 3444 3445 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 3446 'Writes this packet to the supplied buffer' 3447 self._bufferstartoffset=buf.getcurrentoffset() 3448 self.__field_unknown1.writetobuffer(buf) 3449 self.__field_number.writetobuffer(buf) 3450 self.__field_status.writetobuffer(buf) 3451 self.__field_timesent.writetobuffer(buf) 3452 self.__field_timereceived.writetobuffer(buf) 3453 self.__field_unknown2.writetobuffer(buf) 3454 self._bufferendoffset=buf.getcurrentoffset() 3455 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 3456 3457 3458 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 3459 'Reads this packet from the supplied buffer' 3460 self._bufferstartoffset=buf.getcurrentoffset() 3461 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 3462 self.__field_unknown1=UINT(**{'sizeinbytes': 2}) 3463 self.__field_unknown1.readfrombuffer(buf) 3464 self.__field_number=USTRING(**{'sizeinbytes': 49}) 3465 self.__field_number.readfrombuffer(buf) 3466 self.__field_status=UINT(**{'sizeinbytes': 1}) 3467 self.__field_status.readfrombuffer(buf) 3468 self.__field_timesent=LGCALDATE(**{'sizeinbytes': 4}) 3469 self.__field_timesent.readfrombuffer(buf) 3470 self.__field_timereceived=LGCALDATE(**{'sizeinbytes': 4}) 3471 self.__field_timereceived.readfrombuffer(buf) 3472 self.__field_unknown2=DATA(**{'sizeinbytes': 8}) 3473 self.__field_unknown2.readfrombuffer(buf) 3474 self._bufferendoffset=buf.getcurrentoffset() 3475 3476 3477 def __getfield_unknown1(self): 3478 return self.__field_unknown1.getvalue() 3479 3480 def __setfield_unknown1(self, value): 3481 if isinstance(value,UINT): 3482 self.__field_unknown1=value 3483 else: 3484 self.__field_unknown1=UINT(value,**{'sizeinbytes': 2}) 3485 3486 def __delfield_unknown1(self): del self.__field_unknown1 3487 3488 unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 3489 3490 def __getfield_number(self): 3491 return self.__field_number.getvalue() 3492 3493 def __setfield_number(self, value): 3494 if isinstance(value,USTRING): 3495 self.__field_number=value 3496 else: 3497 self.__field_number=USTRING(value,**{'sizeinbytes': 49}) 3498 3499 def __delfield_number(self): del self.__field_number 3500 3501 number=property(__getfield_number, __setfield_number, __delfield_number, None) 3502 3503 def __getfield_status(self): 3504 return self.__field_status.getvalue() 3505 3506 def __setfield_status(self, value): 3507 if isinstance(value,UINT): 3508 self.__field_status=value 3509 else: 3510 self.__field_status=UINT(value,**{'sizeinbytes': 1}) 3511 3512 def __delfield_status(self): del self.__field_status 3513 3514 status=property(__getfield_status, __setfield_status, __delfield_status, None) 3515 3516 def __getfield_timesent(self): 3517 return self.__field_timesent.getvalue() 3518 3519 def __setfield_timesent(self, value): 3520 if isinstance(value,LGCALDATE): 3521 self.__field_timesent=value 3522 else: 3523 self.__field_timesent=LGCALDATE(value,**{'sizeinbytes': 4}) 3524 3525 def __delfield_timesent(self): del self.__field_timesent 3526 3527 timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None) 3528 3529 def __getfield_timereceived(self): 3530 return self.__field_timereceived.getvalue() 3531 3532 def __setfield_timereceived(self, value): 3533 if isinstance(value,LGCALDATE): 3534 self.__field_timereceived=value 3535 else: 3536 self.__field_timereceived=LGCALDATE(value,**{'sizeinbytes': 4}) 3537 3538 def __delfield_timereceived(self): del self.__field_timereceived 3539 3540 timereceived=property(__getfield_timereceived, __setfield_timereceived, __delfield_timereceived, None) 3541 3542 def __getfield_unknown2(self): 3543 return self.__field_unknown2.getvalue() 3544 3545 def __setfield_unknown2(self, value): 3546 if isinstance(value,DATA): 3547 self.__field_unknown2=value 3548 else: 3549 self.__field_unknown2=DATA(value,**{'sizeinbytes': 8}) 3550 3551 def __delfield_unknown2(self): del self.__field_unknown2 3552 3553 unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None) 3554 3555 def iscontainer(self): 3556 return True 3557 3558 def containerelements(self): 3559 yield ('unknown1', self.__field_unknown1, None) 3560 yield ('number', self.__field_number, None) 3561 yield ('status', self.__field_status, None) 3562 yield ('timesent', self.__field_timesent, None) 3563 yield ('timereceived', self.__field_timereceived, None) 3564 yield ('unknown2', self.__field_unknown2, None) 3565 3566 3567 3568 3569 class sms_saved(BaseProtogenClass): 3570 __fields=['outboxmsg', 'pad', 'outbox', 'inbox'] 3571 3572 def __init__(self, *args, **kwargs): 3573 dict={} 3574 # What was supplied to this function 3575 dict.update(kwargs) 3576 # Parent constructor 3577 super(sms_saved,self).__init__(**dict) 3578 if self.__class__ is sms_saved: 3579 self._update(args,dict) 3580 3581 3582 def getfields(self): 3583 return self.__fields 3584 3585 3586 def _update(self, args, kwargs): 3587 super(sms_saved,self)._update(args,kwargs) 3588 keys=kwargs.keys() 3589 for key in keys: 3590 if key in self.__fields: 3591 setattr(self, key, kwargs[key]) 3592 del kwargs[key] 3593 # Were any unrecognized kwargs passed in? 3594 if __debug__: 3595 self._complainaboutunusedargs(sms_saved,kwargs) 3596 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 3597 # Make all P fields that haven't already been constructed 3598 3599 3600 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 3601 'Writes this packet to the supplied buffer' 3602 self._bufferstartoffset=buf.getcurrentoffset() 3603 self.__field_outboxmsg.writetobuffer(buf) 3604 self.__field_pad.writetobuffer(buf) 3605 if self.outboxmsg: 3606 self.__field_outbox.writetobuffer(buf) 3607 if not self.outboxmsg: 3608 self.__field_inbox.writetobuffer(buf) 3609 self._bufferendoffset=buf.getcurrentoffset() 3610 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 3611 3612 3613 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 3614 'Reads this packet from the supplied buffer' 3615 self._bufferstartoffset=buf.getcurrentoffset() 3616 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 3617 self.__field_outboxmsg=UINT(**{'sizeinbytes': 4}) 3618 self.__field_outboxmsg.readfrombuffer(buf) 3619 self.__field_pad=UNKNOWN(**{'sizeinbytes': 4}) 3620 self.__field_pad.readfrombuffer(buf) 3621 if self.outboxmsg: 3622 self.__field_outbox=sms_out() 3623 self.__field_outbox.readfrombuffer(buf) 3624 if not self.outboxmsg: 3625 self.__field_inbox=sms_in() 3626 self.__field_inbox.readfrombuffer(buf) 3627 self._bufferendoffset=buf.getcurrentoffset() 3628 3629 3630 def __getfield_outboxmsg(self): 3631 return self.__field_outboxmsg.getvalue() 3632 3633 def __setfield_outboxmsg(self, value): 3634 if isinstance(value,UINT): 3635 self.__field_outboxmsg=value 3636 else: 3637 self.__field_outboxmsg=UINT(value,**{'sizeinbytes': 4}) 3638 3639 def __delfield_outboxmsg(self): del self.__field_outboxmsg 3640 3641 outboxmsg=property(__getfield_outboxmsg, __setfield_outboxmsg, __delfield_outboxmsg, None) 3642 3643 def __getfield_pad(self): 3644 return self.__field_pad.getvalue() 3645 3646 def __setfield_pad(self, value): 3647 if isinstance(value,UNKNOWN): 3648 self.__field_pad=value 3649 else: 3650 self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 4}) 3651 3652 def __delfield_pad(self): del self.__field_pad 3653 3654 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 3655 3656 def __getfield_outbox(self): 3657 return self.__field_outbox.getvalue() 3658 3659 def __setfield_outbox(self, value): 3660 if isinstance(value,sms_out): 3661 self.__field_outbox=value 3662 else: 3663 self.__field_outbox=sms_out(value,) 3664 3665 def __delfield_outbox(self): del self.__field_outbox 3666 3667 outbox=property(__getfield_outbox, __setfield_outbox, __delfield_outbox, None) 3668 3669 def __getfield_inbox(self): 3670 return self.__field_inbox.getvalue() 3671 3672 def __setfield_inbox(self, value): 3673 if isinstance(value,sms_in): 3674 self.__field_inbox=value 3675 else: 3676 self.__field_inbox=sms_in(value,) 3677 3678 def __delfield_inbox(self): del self.__field_inbox 3679 3680 inbox=property(__getfield_inbox, __setfield_inbox, __delfield_inbox, None) 3681 3682 def iscontainer(self): 3683 return True 3684 3685 def containerelements(self): 3686 yield ('outboxmsg', self.__field_outboxmsg, None) 3687 yield ('pad', self.__field_pad, None) 3688 if self.outboxmsg: 3689 yield ('outbox', self.__field_outbox, None) 3690 if not self.outboxmsg: 3691 yield ('inbox', self.__field_inbox, None) 3692 3693 3694 3695 3696 class sms_out(BaseProtogenClass): 3697 __fields=['index', 'locked', 'unknown1', 'timesent', 'subject', 'unknown2', 'num_msg_elements', 'messages', 'unknown5', 'priority', 'unknown7', 'callback', 'recipients'] 3698 3699 def __init__(self, *args, **kwargs): 3700 dict={} 3701 # What was supplied to this function 3702 dict.update(kwargs) 3703 # Parent constructor 3704 super(sms_out,self).__init__(**dict) 3705 if self.__class__ is sms_out: 3706 self._update(args,dict) 3707 3708 3709 def getfields(self): 3710 return self.__fields 3711 3712 3713 def _update(self, args, kwargs): 3714 super(sms_out,self)._update(args,kwargs) 3715 keys=kwargs.keys() 3716 for key in keys: 3717 if key in self.__fields: 3718 setattr(self, key, kwargs[key]) 3719 del kwargs[key] 3720 # Were any unrecognized kwargs passed in? 3721 if __debug__: 3722 self._complainaboutunusedargs(sms_out,kwargs) 3723 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 3724 # Make all P fields that haven't already been constructed 3725 3726 3727 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 3728 'Writes this packet to the supplied buffer' 3729 self._bufferstartoffset=buf.getcurrentoffset() 3730 self.__field_index.writetobuffer(buf) 3731 self.__field_locked.writetobuffer(buf) 3732 self.__field_unknown1.writetobuffer(buf) 3733 self.__field_timesent.writetobuffer(buf) 3734 self.__field_subject.writetobuffer(buf) 3735 self.__field_unknown2.writetobuffer(buf) 3736 self.__field_num_msg_elements.writetobuffer(buf) 3737 try: self.__field_messages 3738 except: 3739 self.__field_messages=LIST(**{'elementclass': msg_record, 'length': 10}) 3740 self.__field_messages.writetobuffer(buf) 3741 self.__field_unknown5.writetobuffer(buf) 3742 self.__field_priority.writetobuffer(buf) 3743 self.__field_unknown7.writetobuffer(buf) 3744 self.__field_callback.writetobuffer(buf) 3745 try: self.__field_recipients 3746 except: 3747 self.__field_recipients=LIST(**{'elementclass': recipient_record,'length': 10}) 3748 self.__field_recipients.writetobuffer(buf) 3749 self._bufferendoffset=buf.getcurrentoffset() 3750 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 3751 3752 3753 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 3754 'Reads this packet from the supplied buffer' 3755 self._bufferstartoffset=buf.getcurrentoffset() 3756 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 3757 self.__field_index=UINT(**{'sizeinbytes': 4}) 3758 self.__field_index.readfrombuffer(buf) 3759 self.__field_locked=UINT(**{'sizeinbytes': 1}) 3760 self.__field_locked.readfrombuffer(buf) 3761 self.__field_unknown1=UINT(**{'sizeinbytes': 3}) 3762 self.__field_unknown1.readfrombuffer(buf) 3763 self.__field_timesent=LGCALDATE(**{'sizeinbytes': 4}) 3764 self.__field_timesent.readfrombuffer(buf) 3765 self.__field_subject=USTRING(**{'sizeinbytes': 21}) 3766 self.__field_subject.readfrombuffer(buf) 3767 self.__field_unknown2=DATA(**{'sizeinbytes': 151}) 3768 self.__field_unknown2.readfrombuffer(buf) 3769 self.__field_num_msg_elements=UINT(**{'sizeinbytes': 1}) 3770 self.__field_num_msg_elements.readfrombuffer(buf) 3771 self.__field_messages=LIST(**{'elementclass': msg_record, 'length': 10}) 3772 self.__field_messages.readfrombuffer(buf) 3773 self.__field_unknown5=UINT(**{'sizeinbytes': 1}) 3774 self.__field_unknown5.readfrombuffer(buf) 3775 self.__field_priority=UINT(**{'sizeinbytes': 1}) 3776 self.__field_priority.readfrombuffer(buf) 3777 self.__field_unknown7=DATA(**{'sizeinbytes': 14}) 3778 self.__field_unknown7.readfrombuffer(buf) 3779 self.__field_callback=USTRING(**{'sizeinbytes': 49}) 3780 self.__field_callback.readfrombuffer(buf) 3781 self.__field_recipients=LIST(**{'elementclass': recipient_record,'length': 10}) 3782 self.__field_recipients.readfrombuffer(buf) 3783 self._bufferendoffset=buf.getcurrentoffset() 3784 3785 3786 def __getfield_index(self): 3787 return self.__field_index.getvalue() 3788 3789 def __setfield_index(self, value): 3790 if isinstance(value,UINT): 3791 self.__field_index=value 3792 else: 3793 self.__field_index=UINT(value,**{'sizeinbytes': 4}) 3794 3795 def __delfield_index(self): del self.__field_index 3796 3797 index=property(__getfield_index, __setfield_index, __delfield_index, None) 3798 3799 def __getfield_locked(self): 3800 return self.__field_locked.getvalue() 3801 3802 def __setfield_locked(self, value): 3803 if isinstance(value,UINT): 3804 self.__field_locked=value 3805 else: 3806 self.__field_locked=UINT(value,**{'sizeinbytes': 1}) 3807 3808 def __delfield_locked(self): del self.__field_locked 3809 3810 locked=property(__getfield_locked, __setfield_locked, __delfield_locked, None) 3811 3812 def __getfield_unknown1(self): 3813 return self.__field_unknown1.getvalue() 3814 3815 def __setfield_unknown1(self, value): 3816 if isinstance(value,UINT): 3817 self.__field_unknown1=value 3818 else: 3819 self.__field_unknown1=UINT(value,**{'sizeinbytes': 3}) 3820 3821 def __delfield_unknown1(self): del self.__field_unknown1 3822 3823 unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 3824 3825 def __getfield_timesent(self): 3826 return self.__field_timesent.getvalue() 3827 3828 def __setfield_timesent(self, value): 3829 if isinstance(value,LGCALDATE): 3830 self.__field_timesent=value 3831 else: 3832 self.__field_timesent=LGCALDATE(value,**{'sizeinbytes': 4}) 3833 3834 def __delfield_timesent(self): del self.__field_timesent 3835 3836 timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None) 3837 3838 def __getfield_subject(self): 3839 return self.__field_subject.getvalue() 3840 3841 def __setfield_subject(self, value): 3842 if isinstance(value,USTRING): 3843 self.__field_subject=value 3844 else: 3845 self.__field_subject=USTRING(value,**{'sizeinbytes': 21}) 3846 3847 def __delfield_subject(self): del self.__field_subject 3848 3849 subject=property(__getfield_subject, __setfield_subject, __delfield_subject, None) 3850 3851 def __getfield_unknown2(self): 3852 return self.__field_unknown2.getvalue() 3853 3854 def __setfield_unknown2(self, value): 3855 if isinstance(value,DATA): 3856 self.__field_unknown2=value 3857 else: 3858 self.__field_unknown2=DATA(value,**{'sizeinbytes': 151}) 3859 3860 def __delfield_unknown2(self): del self.__field_unknown2 3861 3862 unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None) 3863 3864 def __getfield_num_msg_elements(self): 3865 return self.__field_num_msg_elements.getvalue() 3866 3867 def __setfield_num_msg_elements(self, value): 3868 if isinstance(value,UINT): 3869 self.__field_num_msg_elements=value 3870 else: 3871 self.__field_num_msg_elements=UINT(value,**{'sizeinbytes': 1}) 3872 3873 def __delfield_num_msg_elements(self): del self.__field_num_msg_elements 3874 3875 num_msg_elements=property(__getfield_num_msg_elements, __setfield_num_msg_elements, __delfield_num_msg_elements, None) 3876 3877 def __getfield_messages(self): 3878 try: self.__field_messages 3879 except: 3880 self.__field_messages=LIST(**{'elementclass': msg_record, 'length': 10}) 3881 return self.__field_messages.getvalue() 3882 3883 def __setfield_messages(self, value): 3884 if isinstance(value,LIST): 3885 self.__field_messages=value 3886 else: 3887 self.__field_messages=LIST(value,**{'elementclass': msg_record, 'length': 10}) 3888 3889 def __delfield_messages(self): del self.__field_messages 3890 3891 messages=property(__getfield_messages, __setfield_messages, __delfield_messages, None) 3892 3893 def __getfield_unknown5(self): 3894 return self.__field_unknown5.getvalue() 3895 3896 def __setfield_unknown5(self, value): 3897 if isinstance(value,UINT): 3898 self.__field_unknown5=value 3899 else: 3900 self.__field_unknown5=UINT(value,**{'sizeinbytes': 1}) 3901 3902 def __delfield_unknown5(self): del self.__field_unknown5 3903 3904 unknown5=property(__getfield_unknown5, __setfield_unknown5, __delfield_unknown5, None) 3905 3906 def __getfield_priority(self): 3907 return self.__field_priority.getvalue() 3908 3909 def __setfield_priority(self, value): 3910 if isinstance(value,UINT): 3911 self.__field_priority=value 3912 else: 3913 self.__field_priority=UINT(value,**{'sizeinbytes': 1}) 3914 3915 def __delfield_priority(self): del self.__field_priority 3916 3917 priority=property(__getfield_priority, __setfield_priority, __delfield_priority, None) 3918 3919 def __getfield_unknown7(self): 3920 return self.__field_unknown7.getvalue() 3921 3922 def __setfield_unknown7(self, value): 3923 if isinstance(value,DATA): 3924 self.__field_unknown7=value 3925 else: 3926 self.__field_unknown7=DATA(value,**{'sizeinbytes': 14}) 3927 3928 def __delfield_unknown7(self): del self.__field_unknown7 3929 3930 unknown7=property(__getfield_unknown7, __setfield_unknown7, __delfield_unknown7, None) 3931 3932 def __getfield_callback(self): 3933 return self.__field_callback.getvalue() 3934 3935 def __setfield_callback(self, value): 3936 if isinstance(value,USTRING): 3937 self.__field_callback=value 3938 else: 3939 self.__field_callback=USTRING(value,**{'sizeinbytes': 49}) 3940 3941 def __delfield_callback(self): del self.__field_callback 3942 3943 callback=property(__getfield_callback, __setfield_callback, __delfield_callback, None) 3944 3945 def __getfield_recipients(self): 3946 try: self.__field_recipients 3947 except: 3948 self.__field_recipients=LIST(**{'elementclass': recipient_record,'length': 10}) 3949 return self.__field_recipients.getvalue() 3950 3951 def __setfield_recipients(self, value): 3952 if isinstance(value,LIST): 3953 self.__field_recipients=value 3954 else: 3955 self.__field_recipients=LIST(value,**{'elementclass': recipient_record,'length': 10}) 3956 3957 def __delfield_recipients(self): del self.__field_recipients 3958 3959 recipients=property(__getfield_recipients, __setfield_recipients, __delfield_recipients, None) 3960 3961 def iscontainer(self): 3962 return True 3963 3964 def containerelements(self): 3965 yield ('index', self.__field_index, None) 3966 yield ('locked', self.__field_locked, None) 3967 yield ('unknown1', self.__field_unknown1, None) 3968 yield ('timesent', self.__field_timesent, None) 3969 yield ('subject', self.__field_subject, None) 3970 yield ('unknown2', self.__field_unknown2, None) 3971 yield ('num_msg_elements', self.__field_num_msg_elements, None) 3972 yield ('messages', self.__field_messages, None) 3973 yield ('unknown5', self.__field_unknown5, None) 3974 yield ('priority', self.__field_priority, None) 3975 yield ('unknown7', self.__field_unknown7, None) 3976 yield ('callback', self.__field_callback, None) 3977 yield ('recipients', self.__field_recipients, None) 3978 3979 3980 3981 3982 class SMSINBOXMSGFRAGMENT(BaseProtogenClass): 3983 __fields=['msg'] 3984 3985 def __init__(self, *args, **kwargs): 3986 dict={} 3987 # What was supplied to this function 3988 dict.update(kwargs) 3989 # Parent constructor 3990 super(SMSINBOXMSGFRAGMENT,self).__init__(**dict) 3991 if self.__class__ is SMSINBOXMSGFRAGMENT: 3992 self._update(args,dict) 3993 3994 3995 def getfields(self): 3996 return self.__fields 3997 3998 3999 def _update(self, args, kwargs): 4000 super(SMSINBOXMSGFRAGMENT,self)._update(args,kwargs) 4001 keys=kwargs.keys() 4002 for key in keys: 4003 if key in self.__fields: 4004 setattr(self, key, kwargs[key]) 4005 del kwargs[key] 4006 # Were any unrecognized kwargs passed in? 4007 if __debug__: 4008 self._complainaboutunusedargs(SMSINBOXMSGFRAGMENT,kwargs) 4009 if len(args): 4010 dict2={'elementclass': _gen_p_lgvi125_325, 'length': 181} 4011 dict2.update(kwargs) 4012 kwargs=dict2 4013 self.__field_msg=LIST(*args,**dict2) 4014 # Make all P fields that haven't already been constructed 4015 4016 4017 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 4018 'Writes this packet to the supplied buffer' 4019 self._bufferstartoffset=buf.getcurrentoffset() 4020 try: self.__field_msg 4021 except: 4022 self.__field_msg=LIST(**{'elementclass': _gen_p_lgvi125_325, 'length': 181}) 4023 self.__field_msg.writetobuffer(buf) 4024 self._bufferendoffset=buf.getcurrentoffset() 4025 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 4026 4027 4028 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 4029 'Reads this packet from the supplied buffer' 4030 self._bufferstartoffset=buf.getcurrentoffset() 4031 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 4032 self.__field_msg=LIST(**{'elementclass': _gen_p_lgvi125_325, 'length': 181}) 4033 self.__field_msg.readfrombuffer(buf) 4034 self._bufferendoffset=buf.getcurrentoffset() 4035 4036 4037 def __getfield_msg(self): 4038 try: self.__field_msg 4039 except: 4040 self.__field_msg=LIST(**{'elementclass': _gen_p_lgvi125_325, 'length': 181}) 4041 return self.__field_msg.getvalue() 4042 4043 def __setfield_msg(self, value): 4044 if isinstance(value,LIST): 4045 self.__field_msg=value 4046 else: 4047 self.__field_msg=LIST(value,**{'elementclass': _gen_p_lgvi125_325, 'length': 181}) 4048 4049 def __delfield_msg(self): del self.__field_msg 4050 4051 msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None) 4052 4053 def iscontainer(self): 4054 return True 4055 4056 def containerelements(self): 4057 yield ('msg', self.__field_msg, None) 4058 4059 4060 4061 4062 class _gen_p_lgvi125_325(BaseProtogenClass): 4063 'Anonymous inner class' 4064 __fields=['byte'] 4065 4066 def __init__(self, *args, **kwargs): 4067 dict={} 4068 # What was supplied to this function 4069 dict.update(kwargs) 4070 # Parent constructor 4071 super(_gen_p_lgvi125_325,self).__init__(**dict) 4072 if self.__class__ is _gen_p_lgvi125_325: 4073 self._update(args,dict) 4074 4075 4076 def getfields(self): 4077 return self.__fields 4078 4079 4080 def _update(self, args, kwargs): 4081 super(_gen_p_lgvi125_325,self)._update(args,kwargs) 4082 keys=kwargs.keys() 4083 for key in keys: 4084 if key in self.__fields: 4085 setattr(self, key, kwargs[key]) 4086 del kwargs[key] 4087 # Were any unrecognized kwargs passed in? 4088 if __debug__: 4089 self._complainaboutunusedargs(_gen_p_lgvi125_325,kwargs) 4090 if len(args): 4091 dict2={'sizeinbytes': 1} 4092 dict2.update(kwargs) 4093 kwargs=dict2 4094 self.__field_byte=UINT(*args,**dict2) 4095 # Make all P fields that haven't already been constructed 4096 4097 4098 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 4099 'Writes this packet to the supplied buffer' 4100 self._bufferstartoffset=buf.getcurrentoffset() 4101 self.__field_byte.writetobuffer(buf) 4102 self._bufferendoffset=buf.getcurrentoffset() 4103 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 4104 4105 4106 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 4107 'Reads this packet from the supplied buffer' 4108 self._bufferstartoffset=buf.getcurrentoffset() 4109 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 4110 self.__field_byte=UINT(**{'sizeinbytes': 1}) 4111 self.__field_byte.readfrombuffer(buf) 4112 self._bufferendoffset=buf.getcurrentoffset() 4113 4114 4115 def __getfield_byte(self): 4116 return self.__field_byte.getvalue() 4117 4118 def __setfield_byte(self, value): 4119 if isinstance(value,UINT): 4120 self.__field_byte=value 4121 else: 4122 self.__field_byte=UINT(value,**{'sizeinbytes': 1}) 4123 4124 def __delfield_byte(self): del self.__field_byte 4125 4126 byte=property(__getfield_byte, __setfield_byte, __delfield_byte, "individual byte of message") 4127 4128 def iscontainer(self): 4129 return True 4130 4131 def containerelements(self): 4132 yield ('byte', self.__field_byte, "individual byte of message") 4133 4134 4135 4136 4137 class sms_in(BaseProtogenClass): 4138 __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'] 4139 4140 def __init__(self, *args, **kwargs): 4141 dict={} 4142 # What was supplied to this function 4143 dict.update(kwargs) 4144 # Parent constructor 4145 super(sms_in,self).__init__(**dict) 4146 if self.__class__ is sms_in: 4147 self._update(args,dict) 4148 4149 4150 def getfields(self): 4151 return self.__fields 4152 4153 4154 def _update(self, args, kwargs): 4155 super(sms_in,self)._update(args,kwargs) 4156 keys=kwargs.keys() 4157 for key in keys: 4158 if key in self.__fields: 4159 setattr(self, key, kwargs[key]) 4160 del kwargs[key] 4161 # Were any unrecognized kwargs passed in? 4162 if __debug__: 4163 self._complainaboutunusedargs(sms_in,kwargs) 4164 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 4165 # Make all P fields that haven't already been constructed 4166 4167 4168 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 4169 'Writes this packet to the supplied buffer' 4170 self._bufferstartoffset=buf.getcurrentoffset() 4171 self.__field_msg_index1.writetobuffer(buf) 4172 self.__field_msg_index2.writetobuffer(buf) 4173 self.__field_unknown2.writetobuffer(buf) 4174 self.__field_unknown3.writetobuffer(buf) 4175 self.__field_timesent.writetobuffer(buf) 4176 self.__field_unknown.writetobuffer(buf) 4177 self.__field_callback_length.writetobuffer(buf) 4178 self.__field_callback.writetobuffer(buf) 4179 self.__field_sender_length.writetobuffer(buf) 4180 try: self.__field_sender 4181 except: 4182 self.__field_sender=LIST(**{'elementclass': _gen_p_lgvi125_338, 'length': 38}) 4183 self.__field_sender.writetobuffer(buf) 4184 self.__field_unknown4.writetobuffer(buf) 4185 self.__field_lg_time.writetobuffer(buf) 4186 self.__field_GPStime.writetobuffer(buf) 4187 self.__field_unknown5.writetobuffer(buf) 4188 self.__field_read.writetobuffer(buf) 4189 self.__field_locked.writetobuffer(buf) 4190 self.__field_unknown8.writetobuffer(buf) 4191 self.__field_priority.writetobuffer(buf) 4192 self.__field_flags.writetobuffer(buf) 4193 self.__field_subject.writetobuffer(buf) 4194 self.__field_bin_header1.writetobuffer(buf) 4195 self.__field_bin_header2.writetobuffer(buf) 4196 self.__field_unknown6.writetobuffer(buf) 4197 self.__field_multipartID.writetobuffer(buf) 4198 self.__field_bin_header3.writetobuffer(buf) 4199 self.__field_num_msg_elements.writetobuffer(buf) 4200 try: self.__field_msglengths 4201 except: 4202 self.__field_msglengths=LIST(**{'elementclass': _gen_p_lgvi125_356, 'length': 10}) 4203 self.__field_msglengths.writetobuffer(buf) 4204 try: self.__field_msgs 4205 except: 4206 self.__field_msgs=LIST(**{'length': 10, 'elementclass': SMSINBOXMSGFRAGMENT}) 4207 self.__field_msgs.writetobuffer(buf) 4208 self.__field_unknown5.writetobuffer(buf) 4209 self.__field_senders_name.writetobuffer(buf) 4210 self.__field_unknown6.writetobuffer(buf) 4211 self._bufferendoffset=buf.getcurrentoffset() 4212 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 4213 4214 4215 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 4216 'Reads this packet from the supplied buffer' 4217 self._bufferstartoffset=buf.getcurrentoffset() 4218 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 4219 self.__field_msg_index1=UINT(**{'sizeinbytes': 4}) 4220 self.__field_msg_index1.readfrombuffer(buf) 4221 self.__field_msg_index2=UINT(**{'sizeinbytes': 4}) 4222 self.__field_msg_index2.readfrombuffer(buf) 4223 self.__field_unknown2=UINT(**{'sizeinbytes': 2}) 4224 self.__field_unknown2.readfrombuffer(buf) 4225 self.__field_unknown3=UINT(**{'sizeinbytes': 4}) 4226 self.__field_unknown3.readfrombuffer(buf) 4227 self.__field_timesent=SMSDATE(**{'sizeinbytes': 6}) 4228 self.__field_timesent.readfrombuffer(buf) 4229 self.__field_unknown=UINT(**{'sizeinbytes': 3}) 4230 self.__field_unknown.readfrombuffer(buf) 4231 self.__field_callback_length=UINT(**{'sizeinbytes': 1}) 4232 self.__field_callback_length.readfrombuffer(buf) 4233 self.__field_callback=USTRING(**{'sizeinbytes': 38}) 4234 self.__field_callback.readfrombuffer(buf) 4235 self.__field_sender_length=UINT(**{'sizeinbytes': 1}) 4236 self.__field_sender_length.readfrombuffer(buf) 4237 self.__field_sender=LIST(**{'elementclass': _gen_p_lgvi125_338, 'length': 38}) 4238 self.__field_sender.readfrombuffer(buf) 4239 self.__field_unknown4=DATA(**{'sizeinbytes': 15}) 4240 self.__field_unknown4.readfrombuffer(buf) 4241 self.__field_lg_time=LGCALDATE(**{'sizeinbytes': 4}) 4242 self.__field_lg_time.readfrombuffer(buf) 4243 self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4}) 4244 self.__field_GPStime.readfrombuffer(buf) 4245 self.__field_unknown5=UINT(**{'sizeinbytes': 2}) 4246 self.__field_unknown5.readfrombuffer(buf) 4247 self.__field_read=UINT(**{'sizeinbytes': 1}) 4248 self.__field_read.readfrombuffer(buf) 4249 self.__field_locked=UINT(**{'sizeinbytes': 1}) 4250 self.__field_locked.readfrombuffer(buf) 4251 self.__field_unknown8=UINT(**{'sizeinbytes': 2}) 4252 self.__field_unknown8.readfrombuffer(buf) 4253 self.__field_priority=UINT(**{'sizeinbytes': 1}) 4254 self.__field_priority.readfrombuffer(buf) 4255 self.__field_flags=DATA(**{'sizeinbytes': 5}) 4256 self.__field_flags.readfrombuffer(buf) 4257 self.__field_subject=USTRING(**{'sizeinbytes': 21}) 4258 self.__field_subject.readfrombuffer(buf) 4259 self.__field_bin_header1=UINT(**{'sizeinbytes': 1}) 4260 self.__field_bin_header1.readfrombuffer(buf) 4261 self.__field_bin_header2=UINT(**{'sizeinbytes': 1}) 4262 self.__field_bin_header2.readfrombuffer(buf) 4263 self.__field_unknown6=UINT(**{'sizeinbytes': 2}) 4264 self.__field_unknown6.readfrombuffer(buf) 4265 self.__field_multipartID=UINT(**{'sizeinbytes': 2}) 4266 self.__field_multipartID.readfrombuffer(buf) 4267 self.__field_bin_header3=UINT(**{'sizeinbytes': 1}) 4268 self.__field_bin_header3.readfrombuffer(buf) 4269 self.__field_num_msg_elements=UINT(**{'sizeinbytes': 1}) 4270 self.__field_num_msg_elements.readfrombuffer(buf) 4271 self.__field_msglengths=LIST(**{'elementclass': _gen_p_lgvi125_356, 'length': 10}) 4272 self.__field_msglengths.readfrombuffer(buf) 4273 self.__field_msgs=LIST(**{'length': 10, 'elementclass': SMSINBOXMSGFRAGMENT}) 4274 self.__field_msgs.readfrombuffer(buf) 4275 self.__field_unknown5=DATA(**{'sizeinbytes': 437}) 4276 self.__field_unknown5.readfrombuffer(buf) 4277 self.__field_senders_name=USTRING(**{'sizeinbytes': 33}) 4278 self.__field_senders_name.readfrombuffer(buf) 4279 self.__field_unknown6=DATA(**{'sizeinbytes': 169}) 4280 self.__field_unknown6.readfrombuffer(buf) 4281 self._bufferendoffset=buf.getcurrentoffset() 4282 4283 4284 def __getfield_msg_index1(self): 4285 return self.__field_msg_index1.getvalue() 4286 4287 def __setfield_msg_index1(self, value): 4288 if isinstance(value,UINT): 4289 self.__field_msg_index1=value 4290 else: 4291 self.__field_msg_index1=UINT(value,**{'sizeinbytes': 4}) 4292 4293 def __delfield_msg_index1(self): del self.__field_msg_index1 4294 4295 msg_index1=property(__getfield_msg_index1, __setfield_msg_index1, __delfield_msg_index1, None) 4296 4297 def __getfield_msg_index2(self): 4298 return self.__field_msg_index2.getvalue() 4299 4300 def __setfield_msg_index2(self, value): 4301 if isinstance(value,UINT): 4302 self.__field_msg_index2=value 4303 else: 4304 self.__field_msg_index2=UINT(value,**{'sizeinbytes': 4}) 4305 4306 def __delfield_msg_index2(self): del self.__field_msg_index2 4307 4308 msg_index2=property(__getfield_msg_index2, __setfield_msg_index2, __delfield_msg_index2, None) 4309 4310 def __getfield_unknown2(self): 4311 return self.__field_unknown2.getvalue() 4312 4313 def __setfield_unknown2(self, value): 4314 if isinstance(value,UINT): 4315 self.__field_unknown2=value 4316 else: 4317 self.__field_unknown2=UINT(value,**{'sizeinbytes': 2}) 4318 4319 def __delfield_unknown2(self): del self.__field_unknown2 4320 4321 unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None) 4322 4323 def __getfield_unknown3(self): 4324 return self.__field_unknown3.getvalue() 4325 4326 def __setfield_unknown3(self, value): 4327 if isinstance(value,UINT): 4328 self.__field_unknown3=value 4329 else: 4330 self.__field_unknown3=UINT(value,**{'sizeinbytes': 4}) 4331 4332 def __delfield_unknown3(self): del self.__field_unknown3 4333 4334 unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None) 4335 4336 def __getfield_timesent(self): 4337 return self.__field_timesent.getvalue() 4338 4339 def __setfield_timesent(self, value): 4340 if isinstance(value,SMSDATE): 4341 self.__field_timesent=value 4342 else: 4343 self.__field_timesent=SMSDATE(value,**{'sizeinbytes': 6}) 4344 4345 def __delfield_timesent(self): del self.__field_timesent 4346 4347 timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None) 4348 4349 def __getfield_unknown(self): 4350 return self.__field_unknown.getvalue() 4351 4352 def __setfield_unknown(self, value): 4353 if isinstance(value,UINT): 4354 self.__field_unknown=value 4355 else: 4356 self.__field_unknown=UINT(value,**{'sizeinbytes': 3}) 4357 4358 def __delfield_unknown(self): del self.__field_unknown 4359 4360 unknown=property(__getfield_unknown, __setfield_unknown, __delfield_unknown, None) 4361 4362 def __getfield_callback_length(self): 4363 return self.__field_callback_length.getvalue() 4364 4365 def __setfield_callback_length(self, value): 4366 if isinstance(value,UINT): 4367 self.__field_callback_length=value 4368 else: 4369 self.__field_callback_length=UINT(value,**{'sizeinbytes': 1}) 4370 4371 def __delfield_callback_length(self): del self.__field_callback_length 4372 4373 callback_length=property(__getfield_callback_length, __setfield_callback_length, __delfield_callback_length, None) 4374 4375 def __getfield_callback(self): 4376 return self.__field_callback.getvalue() 4377 4378 def __setfield_callback(self, value): 4379 if isinstance(value,USTRING): 4380 self.__field_callback=value 4381 else: 4382 self.__field_callback=USTRING(value,**{'sizeinbytes': 38}) 4383 4384 def __delfield_callback(self): del self.__field_callback 4385 4386 callback=property(__getfield_callback, __setfield_callback, __delfield_callback, None) 4387 4388 def __getfield_sender_length(self): 4389 return self.__field_sender_length.getvalue() 4390 4391 def __setfield_sender_length(self, value): 4392 if isinstance(value,UINT): 4393 self.__field_sender_length=value 4394 else: 4395 self.__field_sender_length=UINT(value,**{'sizeinbytes': 1}) 4396 4397 def __delfield_sender_length(self): del self.__field_sender_length 4398 4399 sender_length=property(__getfield_sender_length, __setfield_sender_length, __delfield_sender_length, None) 4400 4401 def __getfield_sender(self): 4402 try: self.__field_sender 4403 except: 4404 self.__field_sender=LIST(**{'elementclass': _gen_p_lgvi125_338, 'length': 38}) 4405 return self.__field_sender.getvalue() 4406 4407 def __setfield_sender(self, value): 4408 if isinstance(value,LIST): 4409 self.__field_sender=value 4410 else: 4411 self.__field_sender=LIST(value,**{'elementclass': _gen_p_lgvi125_338, 'length': 38}) 4412 4413 def __delfield_sender(self): del self.__field_sender 4414 4415 sender=property(__getfield_sender, __setfield_sender, __delfield_sender, None) 4416 4417 def __getfield_unknown4(self): 4418 return self.__field_unknown4.getvalue() 4419 4420 def __setfield_unknown4(self, value): 4421 if isinstance(value,DATA): 4422 self.__field_unknown4=value 4423 else: 4424 self.__field_unknown4=DATA(value,**{'sizeinbytes': 15}) 4425 4426 def __delfield_unknown4(self): del self.__field_unknown4 4427 4428 unknown4=property(__getfield_unknown4, __setfield_unknown4, __delfield_unknown4, None) 4429 4430 def __getfield_lg_time(self): 4431 return self.__field_lg_time.getvalue() 4432 4433 def __setfield_lg_time(self, value): 4434 if isinstance(value,LGCALDATE): 4435 self.__field_lg_time=value 4436 else: 4437 self.__field_lg_time=LGCALDATE(value,**{'sizeinbytes': 4}) 4438 4439 def __delfield_lg_time(self): del self.__field_lg_time 4440 4441 lg_time=property(__getfield_lg_time, __setfield_lg_time, __delfield_lg_time, None) 4442 4443 def __getfield_GPStime(self): 4444 return self.__field_GPStime.getvalue() 4445 4446 def __setfield_GPStime(self, value): 4447 if isinstance(value,GPSDATE): 4448 self.__field_GPStime=value 4449 else: 4450 self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4}) 4451 4452 def __delfield_GPStime(self): del self.__field_GPStime 4453 4454 GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None) 4455 4456 def __getfield_unknown5(self): 4457 return self.__field_unknown5.getvalue() 4458 4459 def __setfield_unknown5(self, value): 4460 if isinstance(value,UINT): 4461 self.__field_unknown5=value 4462 else: 4463 self.__field_unknown5=UINT(value,**{'sizeinbytes': 2}) 4464 4465 def __delfield_unknown5(self): del self.__field_unknown5 4466 4467 unknown5=property(__getfield_unknown5, __setfield_unknown5, __delfield_unknown5, None) 4468 4469 def __getfield_read(self): 4470 return self.__field_read.getvalue() 4471 4472 def __setfield_read(self, value): 4473 if isinstance(value,UINT): 4474 self.__field_read=value 4475 else: 4476 self.__field_read=UINT(value,**{'sizeinbytes': 1}) 4477 4478 def __delfield_read(self): del self.__field_read 4479 4480 read=property(__getfield_read, __setfield_read, __delfield_read, None) 4481 4482 def __getfield_locked(self): 4483 return self.__field_locked.getvalue() 4484 4485 def __setfield_locked(self, value): 4486 if isinstance(value,UINT): 4487 self.__field_locked=value 4488 else: 4489 self.__field_locked=UINT(value,**{'sizeinbytes': 1}) 4490 4491 def __delfield_locked(self): del self.__field_locked 4492 4493 locked=property(__getfield_locked, __setfield_locked, __delfield_locked, None) 4494 4495 def __getfield_unknown8(self): 4496 return self.__field_unknown8.getvalue() 4497 4498 def __setfield_unknown8(self, value): 4499 if isinstance(value,UINT): 4500 self.__field_unknown8=value 4501 else: 4502 self.__field_unknown8=UINT(value,**{'sizeinbytes': 2}) 4503 4504 def __delfield_unknown8(self): del self.__field_unknown8 4505 4506 unknown8=property(__getfield_unknown8, __setfield_unknown8, __delfield_unknown8, None) 4507 4508 def __getfield_priority(self): 4509 return self.__field_priority.getvalue() 4510 4511 def __setfield_priority(self, value): 4512 if isinstance(value,UINT): 4513 self.__field_priority=value 4514 else: 4515 self.__field_priority=UINT(value,**{'sizeinbytes': 1}) 4516 4517 def __delfield_priority(self): del self.__field_priority 4518 4519 priority=property(__getfield_priority, __setfield_priority, __delfield_priority, None) 4520 4521 def __getfield_flags(self): 4522 return self.__field_flags.getvalue() 4523 4524 def __setfield_flags(self, value): 4525 if isinstance(value,DATA): 4526 self.__field_flags=value 4527 else: 4528 self.__field_flags=DATA(value,**{'sizeinbytes': 5}) 4529 4530 def __delfield_flags(self): del self.__field_flags 4531 4532 flags=property(__getfield_flags, __setfield_flags, __delfield_flags, None) 4533 4534 def __getfield_subject(self): 4535 return self.__field_subject.getvalue() 4536 4537 def __setfield_subject(self, value): 4538 if isinstance(value,USTRING): 4539 self.__field_subject=value 4540 else: 4541 self.__field_subject=USTRING(value,**{'sizeinbytes': 21}) 4542 4543 def __delfield_subject(self): del self.__field_subject 4544 4545 subject=property(__getfield_subject, __setfield_subject, __delfield_subject, None) 4546 4547 def __getfield_bin_header1(self): 4548 return self.__field_bin_header1.getvalue() 4549 4550 def __setfield_bin_header1(self, value): 4551 if isinstance(value,UINT): 4552 self.__field_bin_header1=value 4553 else: 4554 self.__field_bin_header1=UINT(value,**{'sizeinbytes': 1}) 4555 4556 def __delfield_bin_header1(self): del self.__field_bin_header1 4557 4558 bin_header1=property(__getfield_bin_header1, __setfield_bin_header1, __delfield_bin_header1, None) 4559 4560 def __getfield_bin_header2(self): 4561 return self.__field_bin_header2.getvalue() 4562 4563 def __setfield_bin_header2(self, value): 4564 if isinstance(value,UINT): 4565 self.__field_bin_header2=value 4566 else: 4567 self.__field_bin_header2=UINT(value,**{'sizeinbytes': 1}) 4568 4569 def __delfield_bin_header2(self): del self.__field_bin_header2 4570 4571 bin_header2=property(__getfield_bin_header2, __setfield_bin_header2, __delfield_bin_header2, None) 4572 4573 def __getfield_unknown6(self): 4574 return self.__field_unknown6.getvalue() 4575 4576 def __setfield_unknown6(self, value): 4577 if isinstance(value,UINT): 4578 self.__field_unknown6=value 4579 else: 4580 self.__field_unknown6=UINT(value,**{'sizeinbytes': 2}) 4581 4582 def __delfield_unknown6(self): del self.__field_unknown6 4583 4584 unknown6=property(__getfield_unknown6, __setfield_unknown6, __delfield_unknown6, None) 4585 4586 def __getfield_multipartID(self): 4587 return self.__field_multipartID.getvalue() 4588 4589 def __setfield_multipartID(self, value): 4590 if isinstance(value,UINT): 4591 self.__field_multipartID=value 4592 else: 4593 self.__field_multipartID=UINT(value,**{'sizeinbytes': 2}) 4594 4595 def __delfield_multipartID(self): del self.__field_multipartID 4596 4597 multipartID=property(__getfield_multipartID, __setfield_multipartID, __delfield_multipartID, None) 4598 4599 def __getfield_bin_header3(self): 4600 return self.__field_bin_header3.getvalue() 4601 4602 def __setfield_bin_header3(self, value): 4603 if isinstance(value,UINT): 4604 self.__field_bin_header3=value 4605 else: 4606 self.__field_bin_header3=UINT(value,**{'sizeinbytes': 1}) 4607 4608 def __delfield_bin_header3(self): del self.__field_bin_header3 4609 4610 bin_header3=property(__getfield_bin_header3, __setfield_bin_header3, __delfield_bin_header3, None) 4611 4612 def __getfield_num_msg_elements(self): 4613 return self.__field_num_msg_elements.getvalue() 4614 4615 def __setfield_num_msg_elements(self, value): 4616 if isinstance(value,UINT): 4617 self.__field_num_msg_elements=value 4618 else: 4619 self.__field_num_msg_elements=UINT(value,**{'sizeinbytes': 1}) 4620 4621 def __delfield_num_msg_elements(self): del self.__field_num_msg_elements 4622 4623 num_msg_elements=property(__getfield_num_msg_elements, __setfield_num_msg_elements, __delfield_num_msg_elements, None) 4624 4625 def __getfield_msglengths(self): 4626 try: self.__field_msglengths 4627 except: 4628 self.__field_msglengths=LIST(**{'elementclass': _gen_p_lgvi125_356, 'length': 10}) 4629 return self.__field_msglengths.getvalue() 4630 4631 def __setfield_msglengths(self, value): 4632 if isinstance(value,LIST): 4633 self.__field_msglengths=value 4634 else: 4635 self.__field_msglengths=LIST(value,**{'elementclass': _gen_p_lgvi125_356, 'length': 10}) 4636 4637 def __delfield_msglengths(self): del self.__field_msglengths 4638 4639 msglengths=property(__getfield_msglengths, __setfield_msglengths, __delfield_msglengths, None) 4640 4641 def __getfield_msgs(self): 4642 try: self.__field_msgs 4643 except: 4644 self.__field_msgs=LIST(**{'length': 10, 'elementclass': SMSINBOXMSGFRAGMENT}) 4645 return self.__field_msgs.getvalue() 4646 4647 def __setfield_msgs(self, value): 4648 if isinstance(value,LIST): 4649 self.__field_msgs=value 4650 else: 4651 self.__field_msgs=LIST(value,**{'length': 10, 'elementclass': SMSINBOXMSGFRAGMENT}) 4652 4653 def __delfield_msgs(self): del self.__field_msgs 4654 4655 msgs=property(__getfield_msgs, __setfield_msgs, __delfield_msgs, None) 4656 4657 def __getfield_unknown5(self): 4658 return self.__field_unknown5.getvalue() 4659 4660 def __setfield_unknown5(self, value): 4661 if isinstance(value,DATA): 4662 self.__field_unknown5=value 4663 else: 4664 self.__field_unknown5=DATA(value,**{'sizeinbytes': 437}) 4665 4666 def __delfield_unknown5(self): del self.__field_unknown5 4667 4668 unknown5=property(__getfield_unknown5, __setfield_unknown5, __delfield_unknown5, None) 4669 4670 def __getfield_senders_name(self): 4671 return self.__field_senders_name.getvalue() 4672 4673 def __setfield_senders_name(self, value): 4674 if isinstance(value,USTRING): 4675 self.__field_senders_name=value 4676 else: 4677 self.__field_senders_name=USTRING(value,**{'sizeinbytes': 33}) 4678 4679 def __delfield_senders_name(self): del self.__field_senders_name 4680 4681 senders_name=property(__getfield_senders_name, __setfield_senders_name, __delfield_senders_name, None) 4682 4683 def __getfield_unknown6(self): 4684 return self.__field_unknown6.getvalue() 4685 4686 def __setfield_unknown6(self, value): 4687 if isinstance(value,DATA): 4688 self.__field_unknown6=value 4689 else: 4690 self.__field_unknown6=DATA(value,**{'sizeinbytes': 169}) 4691 4692 def __delfield_unknown6(self): del self.__field_unknown6 4693 4694 unknown6=property(__getfield_unknown6, __setfield_unknown6, __delfield_unknown6, None) 4695 4696 def iscontainer(self): 4697 return True 4698 4699 def containerelements(self): 4700 yield ('msg_index1', self.__field_msg_index1, None) 4701 yield ('msg_index2', self.__field_msg_index2, None) 4702 yield ('unknown2', self.__field_unknown2, None) 4703 yield ('unknown3', self.__field_unknown3, None) 4704 yield ('timesent', self.__field_timesent, None) 4705 yield ('unknown', self.__field_unknown, None) 4706 yield ('callback_length', self.__field_callback_length, None) 4707 yield ('callback', self.__field_callback, None) 4708 yield ('sender_length', self.__field_sender_length, None) 4709 yield ('sender', self.__field_sender, None) 4710 yield ('unknown4', self.__field_unknown4, None) 4711 yield ('lg_time', self.__field_lg_time, None) 4712 yield ('GPStime', self.__field_GPStime, None) 4713 yield ('unknown5', self.__field_unknown5, None) 4714 yield ('read', self.__field_read, None) 4715 yield ('locked', self.__field_locked, None) 4716 yield ('unknown8', self.__field_unknown8, None) 4717 yield ('priority', self.__field_priority, None) 4718 yield ('flags', self.__field_flags, None) 4719 yield ('subject', self.__field_subject, None) 4720 yield ('bin_header1', self.__field_bin_header1, None) 4721 yield ('bin_header2', self.__field_bin_header2, None) 4722 yield ('unknown6', self.__field_unknown6, None) 4723 yield ('multipartID', self.__field_multipartID, None) 4724 yield ('bin_header3', self.__field_bin_header3, None) 4725 yield ('num_msg_elements', self.__field_num_msg_elements, None) 4726 yield ('msglengths', self.__field_msglengths, None) 4727 yield ('msgs', self.__field_msgs, None) 4728 yield ('unknown5', self.__field_unknown5, None) 4729 yield ('senders_name', self.__field_senders_name, None) 4730 yield ('unknown6', self.__field_unknown6, None) 4731 4732 4733 4734 4735 class _gen_p_lgvi125_338(BaseProtogenClass): 4736 'Anonymous inner class' 4737 __fields=['byte'] 4738 4739 def __init__(self, *args, **kwargs): 4740 dict={} 4741 # What was supplied to this function 4742 dict.update(kwargs) 4743 # Parent constructor 4744 super(_gen_p_lgvi125_338,self).__init__(**dict) 4745 if self.__class__ is _gen_p_lgvi125_338: 4746 self._update(args,dict) 4747 4748 4749 def getfields(self): 4750 return self.__fields 4751 4752 4753 def _update(self, args, kwargs): 4754 super(_gen_p_lgvi125_338,self)._update(args,kwargs) 4755 keys=kwargs.keys() 4756 for key in keys: 4757 if key in self.__fields: 4758 setattr(self, key, kwargs[key]) 4759 del kwargs[key] 4760 # Were any unrecognized kwargs passed in? 4761 if __debug__: 4762 self._complainaboutunusedargs(_gen_p_lgvi125_338,kwargs) 4763 if len(args): 4764 dict2={'sizeinbytes': 1} 4765 dict2.update(kwargs) 4766 kwargs=dict2 4767 self.__field_byte=UINT(*args,**dict2) 4768 # Make all P fields that haven't already been constructed 4769 4770 4771 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 4772 'Writes this packet to the supplied buffer' 4773 self._bufferstartoffset=buf.getcurrentoffset() 4774 self.__field_byte.writetobuffer(buf) 4775 self._bufferendoffset=buf.getcurrentoffset() 4776 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 4777 4778 4779 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 4780 'Reads this packet from the supplied buffer' 4781 self._bufferstartoffset=buf.getcurrentoffset() 4782 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 4783 self.__field_byte=UINT(**{'sizeinbytes': 1}) 4784 self.__field_byte.readfrombuffer(buf) 4785 self._bufferendoffset=buf.getcurrentoffset() 4786 4787 4788 def __getfield_byte(self): 4789 return self.__field_byte.getvalue() 4790 4791 def __setfield_byte(self, value): 4792 if isinstance(value,UINT): 4793 self.__field_byte=value 4794 else: 4795 self.__field_byte=UINT(value,**{'sizeinbytes': 1}) 4796 4797 def __delfield_byte(self): del self.__field_byte 4798 4799 byte=property(__getfield_byte, __setfield_byte, __delfield_byte, "individual byte of senders phone number") 4800 4801 def iscontainer(self): 4802 return True 4803 4804 def containerelements(self): 4805 yield ('byte', self.__field_byte, "individual byte of senders phone number") 4806 4807 4808 4809 4810 class _gen_p_lgvi125_356(BaseProtogenClass): 4811 'Anonymous inner class' 4812 __fields=['msglength'] 4813 4814 def __init__(self, *args, **kwargs): 4815 dict={} 4816 # What was supplied to this function 4817 dict.update(kwargs) 4818 # Parent constructor 4819 super(_gen_p_lgvi125_356,self).__init__(**dict) 4820 if self.__class__ is _gen_p_lgvi125_356: 4821 self._update(args,dict) 4822 4823 4824 def getfields(self): 4825 return self.__fields 4826 4827 4828 def _update(self, args, kwargs): 4829 super(_gen_p_lgvi125_356,self)._update(args,kwargs) 4830 keys=kwargs.keys() 4831 for key in keys: 4832 if key in self.__fields: 4833 setattr(self, key, kwargs[key]) 4834 del kwargs[key] 4835 # Were any unrecognized kwargs passed in? 4836 if __debug__: 4837 self._complainaboutunusedargs(_gen_p_lgvi125_356,kwargs) 4838 if len(args): 4839 dict2={'sizeinbytes': 1} 4840 dict2.update(kwargs) 4841 kwargs=dict2 4842 self.__field_msglength=UINT(*args,**dict2) 4843 # Make all P fields that haven't already been constructed 4844 4845 4846 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 4847 'Writes this packet to the supplied buffer' 4848 self._bufferstartoffset=buf.getcurrentoffset() 4849 self.__field_msglength.writetobuffer(buf) 4850 self._bufferendoffset=buf.getcurrentoffset() 4851 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 4852 4853 4854 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 4855 'Reads this packet from the supplied buffer' 4856 self._bufferstartoffset=buf.getcurrentoffset() 4857 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 4858 self.__field_msglength=UINT(**{'sizeinbytes': 1}) 4859 self.__field_msglength.readfrombuffer(buf) 4860 self._bufferendoffset=buf.getcurrentoffset() 4861 4862 4863 def __getfield_msglength(self): 4864 return self.__field_msglength.getvalue() 4865 4866 def __setfield_msglength(self, value): 4867 if isinstance(value,UINT): 4868 self.__field_msglength=value 4869 else: 4870 self.__field_msglength=UINT(value,**{'sizeinbytes': 1}) 4871 4872 def __delfield_msglength(self): del self.__field_msglength 4873 4874 msglength=property(__getfield_msglength, __setfield_msglength, __delfield_msglength, "lengths of individual messages in septets") 4875 4876 def iscontainer(self): 4877 return True 4878 4879 def containerelements(self): 4880 yield ('msglength', self.__field_msglength, "lengths of individual messages in septets") 4881 4882 4883 4884 4885 class sms_quick_text(BaseProtogenClass): 4886 __fields=['msgs'] 4887 4888 def __init__(self, *args, **kwargs): 4889 dict={} 4890 # What was supplied to this function 4891 dict.update(kwargs) 4892 # Parent constructor 4893 super(sms_quick_text,self).__init__(**dict) 4894 if self.__class__ is sms_quick_text: 4895 self._update(args,dict) 4896 4897 4898 def getfields(self): 4899 return self.__fields 4900 4901 4902 def _update(self, args, kwargs): 4903 super(sms_quick_text,self)._update(args,kwargs) 4904 keys=kwargs.keys() 4905 for key in keys: 4906 if key in self.__fields: 4907 setattr(self, key, kwargs[key]) 4908 del kwargs[key] 4909 # Were any unrecognized kwargs passed in? 4910 if __debug__: 4911 self._complainaboutunusedargs(sms_quick_text,kwargs) 4912 if len(args): 4913 dict2={'elementclass': _gen_p_lgvi125_372, } 4914 dict2.update(kwargs) 4915 kwargs=dict2 4916 self.__field_msgs=LIST(*args,**dict2) 4917 # Make all P fields that haven't already been constructed 4918 4919 4920 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 4921 'Writes this packet to the supplied buffer' 4922 self._bufferstartoffset=buf.getcurrentoffset() 4923 try: self.__field_msgs 4924 except: 4925 self.__field_msgs=LIST(**{'elementclass': _gen_p_lgvi125_372, }) 4926 self.__field_msgs.writetobuffer(buf) 4927 self._bufferendoffset=buf.getcurrentoffset() 4928 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 4929 4930 4931 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 4932 'Reads this packet from the supplied buffer' 4933 self._bufferstartoffset=buf.getcurrentoffset() 4934 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 4935 self.__field_msgs=LIST(**{'elementclass': _gen_p_lgvi125_372, }) 4936 self.__field_msgs.readfrombuffer(buf) 4937 self._bufferendoffset=buf.getcurrentoffset() 4938 4939 4940 def __getfield_msgs(self): 4941 try: self.__field_msgs 4942 except: 4943 self.__field_msgs=LIST(**{'elementclass': _gen_p_lgvi125_372, }) 4944 return self.__field_msgs.getvalue() 4945 4946 def __setfield_msgs(self, value): 4947 if isinstance(value,LIST): 4948 self.__field_msgs=value 4949 else: 4950 self.__field_msgs=LIST(value,**{'elementclass': _gen_p_lgvi125_372, }) 4951 4952 def __delfield_msgs(self): del self.__field_msgs 4953 4954 msgs=property(__getfield_msgs, __setfield_msgs, __delfield_msgs, None) 4955 4956 def iscontainer(self): 4957 return True 4958 4959 def containerelements(self): 4960 yield ('msgs', self.__field_msgs, None) 4961 4962 4963 4964 4965 class _gen_p_lgvi125_372(BaseProtogenClass): 4966 'Anonymous inner class' 4967 __fields=['msg'] 4968 4969 def __init__(self, *args, **kwargs): 4970 dict={} 4971 # What was supplied to this function 4972 dict.update(kwargs) 4973 # Parent constructor 4974 super(_gen_p_lgvi125_372,self).__init__(**dict) 4975 if self.__class__ is _gen_p_lgvi125_372: 4976 self._update(args,dict) 4977 4978 4979 def getfields(self): 4980 return self.__fields 4981 4982 4983 def _update(self, args, kwargs): 4984 super(_gen_p_lgvi125_372,self)._update(args,kwargs) 4985 keys=kwargs.keys() 4986 for key in keys: 4987 if key in self.__fields: 4988 setattr(self, key, kwargs[key]) 4989 del kwargs[key] 4990 # Were any unrecognized kwargs passed in? 4991 if __debug__: 4992 self._complainaboutunusedargs(_gen_p_lgvi125_372,kwargs) 4993 if len(args): 4994 dict2={} 4995 dict2.update(kwargs) 4996 kwargs=dict2 4997 self.__field_msg=USTRING(*args,**dict2) 4998 # Make all P fields that haven't already been constructed 4999 5000 5001 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 5002 'Writes this packet to the supplied buffer' 5003 self._bufferstartoffset=buf.getcurrentoffset() 5004 self.__field_msg.writetobuffer(buf) 5005 self._bufferendoffset=buf.getcurrentoffset() 5006 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 5007 5008 5009 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 5010 'Reads this packet from the supplied buffer' 5011 self._bufferstartoffset=buf.getcurrentoffset() 5012 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 5013 self.__field_msg=USTRING(**{}) 5014 self.__field_msg.readfrombuffer(buf) 5015 self._bufferendoffset=buf.getcurrentoffset() 5016 5017 5018 def __getfield_msg(self): 5019 return self.__field_msg.getvalue() 5020 5021 def __setfield_msg(self, value): 5022 if isinstance(value,USTRING): 5023 self.__field_msg=value 5024 else: 5025 self.__field_msg=USTRING(value,**{}) 5026 5027 def __delfield_msg(self): del self.__field_msg 5028 5029 msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None) 5030 5031 def iscontainer(self): 5032 return True 5033 5034 def containerelements(self): 5035 yield ('msg', self.__field_msg, None) 5036 5037 5038 5039 5040
Generated by PyXR 0.9.4