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