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