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