0001 # THIS FILE IS AUTOMATICALLY GENERATED. EDIT THE SOURCE FILE NOT THIS ONE 0002 0003 """Various descriptions of data specific to LG VX8500""" 0004 0005 from common import PhoneBookBusyException 0006 0007 from prototypes import * 0008 from prototypeslg import * 0009 0010 # Make all lg stuff available in this module as well 0011 from p_lg import * 0012 0013 # we are the same as lgvx8300 except as noted below 0014 from p_brew import * 0015 from p_lgvx8300 import * 0016 0017 # We use LSB for all integer like fields 0018 UINT=UINTlsb 0019 BOOL=BOOLlsb 0020 0021 # Phonebook stuff 0022 RTPathIndexFile='pim/pbRingIdSetAsPath.dat' 0023 MsgRTIndexFile='pim/pbMsgRingIdSetAsPath.dat' 0024 WPPathIndexFile='pim/pbPictureIdSetAsPath.dat' 0025 pb_file_name='pim/pbentry.dat' 0026 0027 # Calendar stuff 0028 ##NUMCALENDARENTRIES=?? 0029 0030 #Play List stuff 0031 PLIndexFileName='dload/aodplaylist.lgpl' 0032 PLFilePath='dload' 0033 PLExt='.clgpl' 0034 PLMaxSize=50 # Max number of items per playlist 0035 0036 # T9 User Database, how do we handle the Spanish DB? 0037 T9USERDBFILENAME='t9udb/t9udb_eng.dat' 0038 Default_Header='\x36\x00' \ 0039 '\x00\x00\x00\x00\x00\x00\x00\x00' 0040 Default_Header2= '\xFB\x07\xF6\x0F\xF1\x17' \ 0041 '\xEC\x1F\xE7\x27\xE2\x2F\xDD\x37' \ 0042 '\xD8\x3F\xD3\x47' 0043 class pbfileentry(BaseProtogenClass): 0044 __fields=['serial1', 'entrynumber', 'data1', 'ringtone', 'msgringtone', 'wallpaper', 'data2'] 0045 0046 def __init__(self, *args, **kwargs): 0047 dict={} 0048 # What was supplied to this function 0049 dict.update(kwargs) 0050 # Parent constructor 0051 super(pbfileentry,self).__init__(**dict) 0052 if self.__class__ is pbfileentry: 0053 self._update(args,dict) 0054 0055 0056 def getfields(self): 0057 return self.__fields 0058 0059 0060 def _update(self, args, kwargs): 0061 super(pbfileentry,self)._update(args,kwargs) 0062 keys=kwargs.keys() 0063 for key in keys: 0064 if key in self.__fields: 0065 setattr(self, key, kwargs[key]) 0066 del kwargs[key] 0067 # Were any unrecognized kwargs passed in? 0068 if __debug__: 0069 self._complainaboutunusedargs(pbfileentry,kwargs) 0070 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0071 # Make all P fields that haven't already been constructed 0072 0073 0074 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0075 'Writes this packet to the supplied buffer' 0076 self._bufferstartoffset=buf.getcurrentoffset() 0077 self.__field_serial1.writetobuffer(buf) 0078 self.__field_entrynumber.writetobuffer(buf) 0079 self.__field_data1.writetobuffer(buf) 0080 self.__field_ringtone.writetobuffer(buf) 0081 self.__field_msgringtone.writetobuffer(buf) 0082 self.__field_wallpaper.writetobuffer(buf) 0083 self.__field_data2.writetobuffer(buf) 0084 self._bufferendoffset=buf.getcurrentoffset() 0085 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0086 0087 0088 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0089 'Reads this packet from the supplied buffer' 0090 self._bufferstartoffset=buf.getcurrentoffset() 0091 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0092 self.__field_serial1=UINT(**{'sizeinbytes': 4}) 0093 self.__field_serial1.readfrombuffer(buf) 0094 self.__field_entrynumber=UINT(**{'sizeinbytes': 2}) 0095 self.__field_entrynumber.readfrombuffer(buf) 0096 self.__field_data1=DATA(**{'sizeinbytes': 123}) 0097 self.__field_data1.readfrombuffer(buf) 0098 self.__field_ringtone=UINT(**{'sizeinbytes': 2}) 0099 self.__field_ringtone.readfrombuffer(buf) 0100 self.__field_msgringtone=UINT(**{'sizeinbytes': 2}) 0101 self.__field_msgringtone.readfrombuffer(buf) 0102 self.__field_wallpaper=UINT(**{'sizeinbytes': 2}) 0103 self.__field_wallpaper.readfrombuffer(buf) 0104 self.__field_data2=DATA(**{'sizeinbytes': 250}) 0105 self.__field_data2.readfrombuffer(buf) 0106 self._bufferendoffset=buf.getcurrentoffset() 0107 0108 0109 def __getfield_serial1(self): 0110 return self.__field_serial1.getvalue() 0111 0112 def __setfield_serial1(self, value): 0113 if isinstance(value,UINT): 0114 self.__field_serial1=value 0115 else: 0116 self.__field_serial1=UINT(value,**{'sizeinbytes': 4}) 0117 0118 def __delfield_serial1(self): del self.__field_serial1 0119 0120 serial1=property(__getfield_serial1, __setfield_serial1, __delfield_serial1, None) 0121 0122 def __getfield_entrynumber(self): 0123 return self.__field_entrynumber.getvalue() 0124 0125 def __setfield_entrynumber(self, value): 0126 if isinstance(value,UINT): 0127 self.__field_entrynumber=value 0128 else: 0129 self.__field_entrynumber=UINT(value,**{'sizeinbytes': 2}) 0130 0131 def __delfield_entrynumber(self): del self.__field_entrynumber 0132 0133 entrynumber=property(__getfield_entrynumber, __setfield_entrynumber, __delfield_entrynumber, None) 0134 0135 def __getfield_data1(self): 0136 return self.__field_data1.getvalue() 0137 0138 def __setfield_data1(self, value): 0139 if isinstance(value,DATA): 0140 self.__field_data1=value 0141 else: 0142 self.__field_data1=DATA(value,**{'sizeinbytes': 123}) 0143 0144 def __delfield_data1(self): del self.__field_data1 0145 0146 data1=property(__getfield_data1, __setfield_data1, __delfield_data1, None) 0147 0148 def __getfield_ringtone(self): 0149 return self.__field_ringtone.getvalue() 0150 0151 def __setfield_ringtone(self, value): 0152 if isinstance(value,UINT): 0153 self.__field_ringtone=value 0154 else: 0155 self.__field_ringtone=UINT(value,**{'sizeinbytes': 2}) 0156 0157 def __delfield_ringtone(self): del self.__field_ringtone 0158 0159 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 0160 0161 def __getfield_msgringtone(self): 0162 return self.__field_msgringtone.getvalue() 0163 0164 def __setfield_msgringtone(self, value): 0165 if isinstance(value,UINT): 0166 self.__field_msgringtone=value 0167 else: 0168 self.__field_msgringtone=UINT(value,**{'sizeinbytes': 2}) 0169 0170 def __delfield_msgringtone(self): del self.__field_msgringtone 0171 0172 msgringtone=property(__getfield_msgringtone, __setfield_msgringtone, __delfield_msgringtone, None) 0173 0174 def __getfield_wallpaper(self): 0175 return self.__field_wallpaper.getvalue() 0176 0177 def __setfield_wallpaper(self, value): 0178 if isinstance(value,UINT): 0179 self.__field_wallpaper=value 0180 else: 0181 self.__field_wallpaper=UINT(value,**{'sizeinbytes': 2}) 0182 0183 def __delfield_wallpaper(self): del self.__field_wallpaper 0184 0185 wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None) 0186 0187 def __getfield_data2(self): 0188 return self.__field_data2.getvalue() 0189 0190 def __setfield_data2(self, value): 0191 if isinstance(value,DATA): 0192 self.__field_data2=value 0193 else: 0194 self.__field_data2=DATA(value,**{'sizeinbytes': 250}) 0195 0196 def __delfield_data2(self): del self.__field_data2 0197 0198 data2=property(__getfield_data2, __setfield_data2, __delfield_data2, None) 0199 0200 def iscontainer(self): 0201 return True 0202 0203 def containerelements(self): 0204 yield ('serial1', self.__field_serial1, None) 0205 yield ('entrynumber', self.__field_entrynumber, None) 0206 yield ('data1', self.__field_data1, None) 0207 yield ('ringtone', self.__field_ringtone, None) 0208 yield ('msgringtone', self.__field_msgringtone, None) 0209 yield ('wallpaper', self.__field_wallpaper, None) 0210 yield ('data2', self.__field_data2, None) 0211 0212 0213 0214 0215 class pbfile(BaseProtogenClass): 0216 __fields=['items'] 0217 0218 def __init__(self, *args, **kwargs): 0219 dict={} 0220 # What was supplied to this function 0221 dict.update(kwargs) 0222 # Parent constructor 0223 super(pbfile,self).__init__(**dict) 0224 if self.__class__ is pbfile: 0225 self._update(args,dict) 0226 0227 0228 def getfields(self): 0229 return self.__fields 0230 0231 0232 def _update(self, args, kwargs): 0233 super(pbfile,self)._update(args,kwargs) 0234 keys=kwargs.keys() 0235 for key in keys: 0236 if key in self.__fields: 0237 setattr(self, key, kwargs[key]) 0238 del kwargs[key] 0239 # Were any unrecognized kwargs passed in? 0240 if __debug__: 0241 self._complainaboutunusedargs(pbfile,kwargs) 0242 if len(args): 0243 dict2={ 'elementclass': pbfileentry } 0244 dict2.update(kwargs) 0245 kwargs=dict2 0246 self.__field_items=LIST(*args,**dict2) 0247 # Make all P fields that haven't already been constructed 0248 0249 0250 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0251 'Writes this packet to the supplied buffer' 0252 self._bufferstartoffset=buf.getcurrentoffset() 0253 self.__field_items.writetobuffer(buf) 0254 self._bufferendoffset=buf.getcurrentoffset() 0255 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0256 0257 0258 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0259 'Reads this packet from the supplied buffer' 0260 self._bufferstartoffset=buf.getcurrentoffset() 0261 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0262 self.__field_items=LIST(**{ 'elementclass': pbfileentry }) 0263 self.__field_items.readfrombuffer(buf) 0264 self._bufferendoffset=buf.getcurrentoffset() 0265 0266 0267 def __getfield_items(self): 0268 return self.__field_items.getvalue() 0269 0270 def __setfield_items(self, value): 0271 if isinstance(value,LIST): 0272 self.__field_items=value 0273 else: 0274 self.__field_items=LIST(value,**{ 'elementclass': pbfileentry }) 0275 0276 def __delfield_items(self): del self.__field_items 0277 0278 items=property(__getfield_items, __setfield_items, __delfield_items, None) 0279 0280 def iscontainer(self): 0281 return True 0282 0283 def containerelements(self): 0284 yield ('items', self.__field_items, None) 0285 0286 0287 0288 0289 class PathIndexEntry(BaseProtogenClass): 0290 __fields=['pathname'] 0291 0292 def __init__(self, *args, **kwargs): 0293 dict={} 0294 # What was supplied to this function 0295 dict.update(kwargs) 0296 # Parent constructor 0297 super(PathIndexEntry,self).__init__(**dict) 0298 if self.__class__ is PathIndexEntry: 0299 self._update(args,dict) 0300 0301 0302 def getfields(self): 0303 return self.__fields 0304 0305 0306 def _update(self, args, kwargs): 0307 super(PathIndexEntry,self)._update(args,kwargs) 0308 keys=kwargs.keys() 0309 for key in keys: 0310 if key in self.__fields: 0311 setattr(self, key, kwargs[key]) 0312 del kwargs[key] 0313 # Were any unrecognized kwargs passed in? 0314 if __debug__: 0315 self._complainaboutunusedargs(PathIndexEntry,kwargs) 0316 if len(args): 0317 dict2={'sizeinbytes': 255, 'encoding': PHONE_ENCODING, 'default': '' } 0318 dict2.update(kwargs) 0319 kwargs=dict2 0320 self.__field_pathname=USTRING(*args,**dict2) 0321 # Make all P fields that haven't already been constructed 0322 0323 0324 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0325 'Writes this packet to the supplied buffer' 0326 self._bufferstartoffset=buf.getcurrentoffset() 0327 try: self.__field_pathname 0328 except: 0329 self.__field_pathname=USTRING(**{'sizeinbytes': 255, 'encoding': PHONE_ENCODING, 'default': '' }) 0330 self.__field_pathname.writetobuffer(buf) 0331 self._bufferendoffset=buf.getcurrentoffset() 0332 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0333 0334 0335 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0336 'Reads this packet from the supplied buffer' 0337 self._bufferstartoffset=buf.getcurrentoffset() 0338 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0339 self.__field_pathname=USTRING(**{'sizeinbytes': 255, 'encoding': PHONE_ENCODING, 'default': '' }) 0340 self.__field_pathname.readfrombuffer(buf) 0341 self._bufferendoffset=buf.getcurrentoffset() 0342 0343 0344 def __getfield_pathname(self): 0345 try: self.__field_pathname 0346 except: 0347 self.__field_pathname=USTRING(**{'sizeinbytes': 255, 'encoding': PHONE_ENCODING, 'default': '' }) 0348 return self.__field_pathname.getvalue() 0349 0350 def __setfield_pathname(self, value): 0351 if isinstance(value,USTRING): 0352 self.__field_pathname=value 0353 else: 0354 self.__field_pathname=USTRING(value,**{'sizeinbytes': 255, 'encoding': PHONE_ENCODING, 'default': '' }) 0355 0356 def __delfield_pathname(self): del self.__field_pathname 0357 0358 pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None) 0359 0360 def iscontainer(self): 0361 return True 0362 0363 def containerelements(self): 0364 yield ('pathname', self.__field_pathname, None) 0365 0366 0367 0368 0369 class PathIndexFile(BaseProtogenClass): 0370 __fields=['items'] 0371 0372 def __init__(self, *args, **kwargs): 0373 dict={} 0374 # What was supplied to this function 0375 dict.update(kwargs) 0376 # Parent constructor 0377 super(PathIndexFile,self).__init__(**dict) 0378 if self.__class__ is PathIndexFile: 0379 self._update(args,dict) 0380 0381 0382 def getfields(self): 0383 return self.__fields 0384 0385 0386 def _update(self, args, kwargs): 0387 super(PathIndexFile,self)._update(args,kwargs) 0388 keys=kwargs.keys() 0389 for key in keys: 0390 if key in self.__fields: 0391 setattr(self, key, kwargs[key]) 0392 del kwargs[key] 0393 # Were any unrecognized kwargs passed in? 0394 if __debug__: 0395 self._complainaboutunusedargs(PathIndexFile,kwargs) 0396 if len(args): 0397 dict2={ 'elementclass': PathIndexEntry, 'createdefault': True, 'length': NUMPHONEBOOKENTRIES } 0398 dict2.update(kwargs) 0399 kwargs=dict2 0400 self.__field_items=LIST(*args,**dict2) 0401 # Make all P fields that haven't already been constructed 0402 0403 0404 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0405 'Writes this packet to the supplied buffer' 0406 self._bufferstartoffset=buf.getcurrentoffset() 0407 try: self.__field_items 0408 except: 0409 self.__field_items=LIST(**{ 'elementclass': PathIndexEntry, 'createdefault': True, 'length': NUMPHONEBOOKENTRIES }) 0410 self.__field_items.writetobuffer(buf) 0411 self._bufferendoffset=buf.getcurrentoffset() 0412 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0413 0414 0415 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0416 'Reads this packet from the supplied buffer' 0417 self._bufferstartoffset=buf.getcurrentoffset() 0418 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0419 self.__field_items=LIST(**{ 'elementclass': PathIndexEntry, 'createdefault': True, 'length': NUMPHONEBOOKENTRIES }) 0420 self.__field_items.readfrombuffer(buf) 0421 self._bufferendoffset=buf.getcurrentoffset() 0422 0423 0424 def __getfield_items(self): 0425 try: self.__field_items 0426 except: 0427 self.__field_items=LIST(**{ 'elementclass': PathIndexEntry, 'createdefault': True, 'length': NUMPHONEBOOKENTRIES }) 0428 return self.__field_items.getvalue() 0429 0430 def __setfield_items(self, value): 0431 if isinstance(value,LIST): 0432 self.__field_items=value 0433 else: 0434 self.__field_items=LIST(value,**{ 'elementclass': PathIndexEntry, 'createdefault': True, 'length': NUMPHONEBOOKENTRIES }) 0435 0436 def __delfield_items(self): del self.__field_items 0437 0438 items=property(__getfield_items, __setfield_items, __delfield_items, None) 0439 0440 def iscontainer(self): 0441 return True 0442 0443 def containerelements(self): 0444 yield ('items', self.__field_items, None) 0445 0446 0447 0448 0449 class PLIndexEntry(BaseProtogenClass): 0450 __fields=['pathname'] 0451 0452 def __init__(self, *args, **kwargs): 0453 dict={} 0454 # What was supplied to this function 0455 dict.update(kwargs) 0456 # Parent constructor 0457 super(PLIndexEntry,self).__init__(**dict) 0458 if self.__class__ is PLIndexEntry: 0459 self._update(args,dict) 0460 0461 0462 def getfields(self): 0463 return self.__fields 0464 0465 0466 def _update(self, args, kwargs): 0467 super(PLIndexEntry,self)._update(args,kwargs) 0468 keys=kwargs.keys() 0469 for key in keys: 0470 if key in self.__fields: 0471 setattr(self, key, kwargs[key]) 0472 del kwargs[key] 0473 # Were any unrecognized kwargs passed in? 0474 if __debug__: 0475 self._complainaboutunusedargs(PLIndexEntry,kwargs) 0476 if len(args): 0477 dict2={'sizeinbytes': 255, 'encoding': PHONE_ENCODING } 0478 dict2.update(kwargs) 0479 kwargs=dict2 0480 self.__field_pathname=USTRING(*args,**dict2) 0481 # Make all P fields that haven't already been constructed 0482 0483 0484 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0485 'Writes this packet to the supplied buffer' 0486 self._bufferstartoffset=buf.getcurrentoffset() 0487 self.__field_pathname.writetobuffer(buf) 0488 self._bufferendoffset=buf.getcurrentoffset() 0489 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0490 0491 0492 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0493 'Reads this packet from the supplied buffer' 0494 self._bufferstartoffset=buf.getcurrentoffset() 0495 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0496 self.__field_pathname=USTRING(**{'sizeinbytes': 255, 'encoding': PHONE_ENCODING }) 0497 self.__field_pathname.readfrombuffer(buf) 0498 self._bufferendoffset=buf.getcurrentoffset() 0499 0500 0501 def __getfield_pathname(self): 0502 return self.__field_pathname.getvalue() 0503 0504 def __setfield_pathname(self, value): 0505 if isinstance(value,USTRING): 0506 self.__field_pathname=value 0507 else: 0508 self.__field_pathname=USTRING(value,**{'sizeinbytes': 255, 'encoding': PHONE_ENCODING }) 0509 0510 def __delfield_pathname(self): del self.__field_pathname 0511 0512 pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None) 0513 0514 def iscontainer(self): 0515 return True 0516 0517 def containerelements(self): 0518 yield ('pathname', self.__field_pathname, None) 0519 0520 0521 0522 0523 class PLIndexFile(BaseProtogenClass): 0524 __fields=['items'] 0525 0526 def __init__(self, *args, **kwargs): 0527 dict={} 0528 # What was supplied to this function 0529 dict.update(kwargs) 0530 # Parent constructor 0531 super(PLIndexFile,self).__init__(**dict) 0532 if self.__class__ is PLIndexFile: 0533 self._update(args,dict) 0534 0535 0536 def getfields(self): 0537 return self.__fields 0538 0539 0540 def _update(self, args, kwargs): 0541 super(PLIndexFile,self)._update(args,kwargs) 0542 keys=kwargs.keys() 0543 for key in keys: 0544 if key in self.__fields: 0545 setattr(self, key, kwargs[key]) 0546 del kwargs[key] 0547 # Were any unrecognized kwargs passed in? 0548 if __debug__: 0549 self._complainaboutunusedargs(PLIndexFile,kwargs) 0550 if len(args): 0551 dict2={ 'elementclass': PLIndexEntry, 'createdefault': True } 0552 dict2.update(kwargs) 0553 kwargs=dict2 0554 self.__field_items=LIST(*args,**dict2) 0555 # Make all P fields that haven't already been constructed 0556 0557 0558 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0559 'Writes this packet to the supplied buffer' 0560 self._bufferstartoffset=buf.getcurrentoffset() 0561 try: self.__field_items 0562 except: 0563 self.__field_items=LIST(**{ 'elementclass': PLIndexEntry, 'createdefault': True }) 0564 self.__field_items.writetobuffer(buf) 0565 self._bufferendoffset=buf.getcurrentoffset() 0566 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0567 0568 0569 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0570 'Reads this packet from the supplied buffer' 0571 self._bufferstartoffset=buf.getcurrentoffset() 0572 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0573 self.__field_items=LIST(**{ 'elementclass': PLIndexEntry, 'createdefault': True }) 0574 self.__field_items.readfrombuffer(buf) 0575 self._bufferendoffset=buf.getcurrentoffset() 0576 0577 0578 def __getfield_items(self): 0579 try: self.__field_items 0580 except: 0581 self.__field_items=LIST(**{ 'elementclass': PLIndexEntry, 'createdefault': True }) 0582 return self.__field_items.getvalue() 0583 0584 def __setfield_items(self, value): 0585 if isinstance(value,LIST): 0586 self.__field_items=value 0587 else: 0588 self.__field_items=LIST(value,**{ 'elementclass': PLIndexEntry, 'createdefault': True }) 0589 0590 def __delfield_items(self): del self.__field_items 0591 0592 items=property(__getfield_items, __setfield_items, __delfield_items, None) 0593 0594 def iscontainer(self): 0595 return True 0596 0597 def containerelements(self): 0598 yield ('items', self.__field_items, None) 0599 0600 0601 0602 0603 class PLSongEntry(BaseProtogenClass): 0604 __fields=['pathname', 'tunename', 'artistname', 'albumname', 'genre', 'dunno1', 'date', 'size', 'zero'] 0605 0606 def __init__(self, *args, **kwargs): 0607 dict={} 0608 # What was supplied to this function 0609 dict.update(kwargs) 0610 # Parent constructor 0611 super(PLSongEntry,self).__init__(**dict) 0612 if self.__class__ is PLSongEntry: 0613 self._update(args,dict) 0614 0615 0616 def getfields(self): 0617 return self.__fields 0618 0619 0620 def _update(self, args, kwargs): 0621 super(PLSongEntry,self)._update(args,kwargs) 0622 keys=kwargs.keys() 0623 for key in keys: 0624 if key in self.__fields: 0625 setattr(self, key, kwargs[key]) 0626 del kwargs[key] 0627 # Were any unrecognized kwargs passed in? 0628 if __debug__: 0629 self._complainaboutunusedargs(PLSongEntry,kwargs) 0630 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0631 # Make all P fields that haven't already been constructed 0632 0633 0634 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0635 'Writes this packet to the supplied buffer' 0636 self._bufferstartoffset=buf.getcurrentoffset() 0637 self.__field_pathname.writetobuffer(buf) 0638 try: self.__field_tunename 0639 except: 0640 self.__field_tunename=USTRING(**{'sizeinbytes': 255, 'encoding': PHONE_ENCODING, 'default': self.pathname }) 0641 self.__field_tunename.writetobuffer(buf) 0642 try: self.__field_artistname 0643 except: 0644 self.__field_artistname=USTRING(**{'sizeinbytes': 100, 'encoding': PHONE_ENCODING, 'default': 'Unknown' }) 0645 self.__field_artistname.writetobuffer(buf) 0646 try: self.__field_albumname 0647 except: 0648 self.__field_albumname=USTRING(**{'sizeinbytes': 100, 'encoding': PHONE_ENCODING, 'default': 'Unknown' }) 0649 self.__field_albumname.writetobuffer(buf) 0650 try: self.__field_genre 0651 except: 0652 self.__field_genre=USTRING(**{'sizeinbytes': 102, 'encoding': PHONE_ENCODING, 'default': 'Unknown' }) 0653 self.__field_genre.writetobuffer(buf) 0654 try: self.__field_dunno1 0655 except: 0656 self.__field_dunno1=UINT(**{'sizeinbytes': 4, 'default': 2 }) 0657 self.__field_dunno1.writetobuffer(buf) 0658 try: self.__field_date 0659 except: 0660 self.__field_date=GPSDATE(**{'sizeinbytes': 4, 'default': GPSDATE.now() }) 0661 self.__field_date.writetobuffer(buf) 0662 self.__field_size.writetobuffer(buf) 0663 try: self.__field_zero 0664 except: 0665 self.__field_zero=UINT(**{'sizeinbytes': 4, 'default': 0 }) 0666 self.__field_zero.writetobuffer(buf) 0667 self._bufferendoffset=buf.getcurrentoffset() 0668 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0669 0670 0671 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0672 'Reads this packet from the supplied buffer' 0673 self._bufferstartoffset=buf.getcurrentoffset() 0674 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0675 self.__field_pathname=USTRING(**{'sizeinbytes': 255, 'encoding': PHONE_ENCODING }) 0676 self.__field_pathname.readfrombuffer(buf) 0677 self.__field_tunename=USTRING(**{'sizeinbytes': 255, 'encoding': PHONE_ENCODING, 'default': self.pathname }) 0678 self.__field_tunename.readfrombuffer(buf) 0679 self.__field_artistname=USTRING(**{'sizeinbytes': 100, 'encoding': PHONE_ENCODING, 'default': 'Unknown' }) 0680 self.__field_artistname.readfrombuffer(buf) 0681 self.__field_albumname=USTRING(**{'sizeinbytes': 100, 'encoding': PHONE_ENCODING, 'default': 'Unknown' }) 0682 self.__field_albumname.readfrombuffer(buf) 0683 self.__field_genre=USTRING(**{'sizeinbytes': 102, 'encoding': PHONE_ENCODING, 'default': 'Unknown' }) 0684 self.__field_genre.readfrombuffer(buf) 0685 self.__field_dunno1=UINT(**{'sizeinbytes': 4, 'default': 2 }) 0686 self.__field_dunno1.readfrombuffer(buf) 0687 self.__field_date=GPSDATE(**{'sizeinbytes': 4, 'default': GPSDATE.now() }) 0688 self.__field_date.readfrombuffer(buf) 0689 self.__field_size=UINT(**{'sizeinbytes': 4}) 0690 self.__field_size.readfrombuffer(buf) 0691 self.__field_zero=UINT(**{'sizeinbytes': 4, 'default': 0 }) 0692 self.__field_zero.readfrombuffer(buf) 0693 self._bufferendoffset=buf.getcurrentoffset() 0694 0695 0696 def __getfield_pathname(self): 0697 return self.__field_pathname.getvalue() 0698 0699 def __setfield_pathname(self, value): 0700 if isinstance(value,USTRING): 0701 self.__field_pathname=value 0702 else: 0703 self.__field_pathname=USTRING(value,**{'sizeinbytes': 255, 'encoding': PHONE_ENCODING }) 0704 0705 def __delfield_pathname(self): del self.__field_pathname 0706 0707 pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None) 0708 0709 def __getfield_tunename(self): 0710 try: self.__field_tunename 0711 except: 0712 self.__field_tunename=USTRING(**{'sizeinbytes': 255, 'encoding': PHONE_ENCODING, 'default': self.pathname }) 0713 return self.__field_tunename.getvalue() 0714 0715 def __setfield_tunename(self, value): 0716 if isinstance(value,USTRING): 0717 self.__field_tunename=value 0718 else: 0719 self.__field_tunename=USTRING(value,**{'sizeinbytes': 255, 'encoding': PHONE_ENCODING, 'default': self.pathname }) 0720 0721 def __delfield_tunename(self): del self.__field_tunename 0722 0723 tunename=property(__getfield_tunename, __setfield_tunename, __delfield_tunename, None) 0724 0725 def __getfield_artistname(self): 0726 try: self.__field_artistname 0727 except: 0728 self.__field_artistname=USTRING(**{'sizeinbytes': 100, 'encoding': PHONE_ENCODING, 'default': 'Unknown' }) 0729 return self.__field_artistname.getvalue() 0730 0731 def __setfield_artistname(self, value): 0732 if isinstance(value,USTRING): 0733 self.__field_artistname=value 0734 else: 0735 self.__field_artistname=USTRING(value,**{'sizeinbytes': 100, 'encoding': PHONE_ENCODING, 'default': 'Unknown' }) 0736 0737 def __delfield_artistname(self): del self.__field_artistname 0738 0739 artistname=property(__getfield_artistname, __setfield_artistname, __delfield_artistname, None) 0740 0741 def __getfield_albumname(self): 0742 try: self.__field_albumname 0743 except: 0744 self.__field_albumname=USTRING(**{'sizeinbytes': 100, 'encoding': PHONE_ENCODING, 'default': 'Unknown' }) 0745 return self.__field_albumname.getvalue() 0746 0747 def __setfield_albumname(self, value): 0748 if isinstance(value,USTRING): 0749 self.__field_albumname=value 0750 else: 0751 self.__field_albumname=USTRING(value,**{'sizeinbytes': 100, 'encoding': PHONE_ENCODING, 'default': 'Unknown' }) 0752 0753 def __delfield_albumname(self): del self.__field_albumname 0754 0755 albumname=property(__getfield_albumname, __setfield_albumname, __delfield_albumname, None) 0756 0757 def __getfield_genre(self): 0758 try: self.__field_genre 0759 except: 0760 self.__field_genre=USTRING(**{'sizeinbytes': 102, 'encoding': PHONE_ENCODING, 'default': 'Unknown' }) 0761 return self.__field_genre.getvalue() 0762 0763 def __setfield_genre(self, value): 0764 if isinstance(value,USTRING): 0765 self.__field_genre=value 0766 else: 0767 self.__field_genre=USTRING(value,**{'sizeinbytes': 102, 'encoding': PHONE_ENCODING, 'default': 'Unknown' }) 0768 0769 def __delfield_genre(self): del self.__field_genre 0770 0771 genre=property(__getfield_genre, __setfield_genre, __delfield_genre, None) 0772 0773 def __getfield_dunno1(self): 0774 try: self.__field_dunno1 0775 except: 0776 self.__field_dunno1=UINT(**{'sizeinbytes': 4, 'default': 2 }) 0777 return self.__field_dunno1.getvalue() 0778 0779 def __setfield_dunno1(self, value): 0780 if isinstance(value,UINT): 0781 self.__field_dunno1=value 0782 else: 0783 self.__field_dunno1=UINT(value,**{'sizeinbytes': 4, 'default': 2 }) 0784 0785 def __delfield_dunno1(self): del self.__field_dunno1 0786 0787 dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None) 0788 0789 def __getfield_date(self): 0790 try: self.__field_date 0791 except: 0792 self.__field_date=GPSDATE(**{'sizeinbytes': 4, 'default': GPSDATE.now() }) 0793 return self.__field_date.getvalue() 0794 0795 def __setfield_date(self, value): 0796 if isinstance(value,GPSDATE): 0797 self.__field_date=value 0798 else: 0799 self.__field_date=GPSDATE(value,**{'sizeinbytes': 4, 'default': GPSDATE.now() }) 0800 0801 def __delfield_date(self): del self.__field_date 0802 0803 date=property(__getfield_date, __setfield_date, __delfield_date, None) 0804 0805 def __getfield_size(self): 0806 return self.__field_size.getvalue() 0807 0808 def __setfield_size(self, value): 0809 if isinstance(value,UINT): 0810 self.__field_size=value 0811 else: 0812 self.__field_size=UINT(value,**{'sizeinbytes': 4}) 0813 0814 def __delfield_size(self): del self.__field_size 0815 0816 size=property(__getfield_size, __setfield_size, __delfield_size, None) 0817 0818 def __getfield_zero(self): 0819 try: self.__field_zero 0820 except: 0821 self.__field_zero=UINT(**{'sizeinbytes': 4, 'default': 0 }) 0822 return self.__field_zero.getvalue() 0823 0824 def __setfield_zero(self, value): 0825 if isinstance(value,UINT): 0826 self.__field_zero=value 0827 else: 0828 self.__field_zero=UINT(value,**{'sizeinbytes': 4, 'default': 0 }) 0829 0830 def __delfield_zero(self): del self.__field_zero 0831 0832 zero=property(__getfield_zero, __setfield_zero, __delfield_zero, None) 0833 0834 def iscontainer(self): 0835 return True 0836 0837 def containerelements(self): 0838 yield ('pathname', self.__field_pathname, None) 0839 yield ('tunename', self.__field_tunename, None) 0840 yield ('artistname', self.__field_artistname, None) 0841 yield ('albumname', self.__field_albumname, None) 0842 yield ('genre', self.__field_genre, None) 0843 yield ('dunno1', self.__field_dunno1, None) 0844 yield ('date', self.__field_date, None) 0845 yield ('size', self.__field_size, None) 0846 yield ('zero', self.__field_zero, None) 0847 0848 0849 0850 0851 class PLPlayListFile(BaseProtogenClass): 0852 __fields=['items'] 0853 0854 def __init__(self, *args, **kwargs): 0855 dict={} 0856 # What was supplied to this function 0857 dict.update(kwargs) 0858 # Parent constructor 0859 super(PLPlayListFile,self).__init__(**dict) 0860 if self.__class__ is PLPlayListFile: 0861 self._update(args,dict) 0862 0863 0864 def getfields(self): 0865 return self.__fields 0866 0867 0868 def _update(self, args, kwargs): 0869 super(PLPlayListFile,self)._update(args,kwargs) 0870 keys=kwargs.keys() 0871 for key in keys: 0872 if key in self.__fields: 0873 setattr(self, key, kwargs[key]) 0874 del kwargs[key] 0875 # Were any unrecognized kwargs passed in? 0876 if __debug__: 0877 self._complainaboutunusedargs(PLPlayListFile,kwargs) 0878 if len(args): 0879 dict2={ 'elementclass': PLSongEntry, 'createdefault': True } 0880 dict2.update(kwargs) 0881 kwargs=dict2 0882 self.__field_items=LIST(*args,**dict2) 0883 # Make all P fields that haven't already been constructed 0884 0885 0886 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0887 'Writes this packet to the supplied buffer' 0888 self._bufferstartoffset=buf.getcurrentoffset() 0889 try: self.__field_items 0890 except: 0891 self.__field_items=LIST(**{ 'elementclass': PLSongEntry, 'createdefault': True }) 0892 self.__field_items.writetobuffer(buf) 0893 self._bufferendoffset=buf.getcurrentoffset() 0894 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0895 0896 0897 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0898 'Reads this packet from the supplied buffer' 0899 self._bufferstartoffset=buf.getcurrentoffset() 0900 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0901 self.__field_items=LIST(**{ 'elementclass': PLSongEntry, 'createdefault': True }) 0902 self.__field_items.readfrombuffer(buf) 0903 self._bufferendoffset=buf.getcurrentoffset() 0904 0905 0906 def __getfield_items(self): 0907 try: self.__field_items 0908 except: 0909 self.__field_items=LIST(**{ 'elementclass': PLSongEntry, 'createdefault': True }) 0910 return self.__field_items.getvalue() 0911 0912 def __setfield_items(self, value): 0913 if isinstance(value,LIST): 0914 self.__field_items=value 0915 else: 0916 self.__field_items=LIST(value,**{ 'elementclass': PLSongEntry, 'createdefault': True }) 0917 0918 def __delfield_items(self): del self.__field_items 0919 0920 items=property(__getfield_items, __setfield_items, __delfield_items, None) 0921 0922 def iscontainer(self): 0923 return True 0924 0925 def containerelements(self): 0926 yield ('items', self.__field_items, None) 0927 0928 0929 0930 0931 class msg_record(BaseProtogenClass): 0932 __fields=['binary', 'unknown3', 'unknown4', 'unknown6', 'length', 'msg'] 0933 0934 def __init__(self, *args, **kwargs): 0935 dict={} 0936 # What was supplied to this function 0937 dict.update(kwargs) 0938 # Parent constructor 0939 super(msg_record,self).__init__(**dict) 0940 if self.__class__ is msg_record: 0941 self._update(args,dict) 0942 0943 0944 def getfields(self): 0945 return self.__fields 0946 0947 0948 def _update(self, args, kwargs): 0949 super(msg_record,self)._update(args,kwargs) 0950 keys=kwargs.keys() 0951 for key in keys: 0952 if key in self.__fields: 0953 setattr(self, key, kwargs[key]) 0954 del kwargs[key] 0955 # Were any unrecognized kwargs passed in? 0956 if __debug__: 0957 self._complainaboutunusedargs(msg_record,kwargs) 0958 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0959 # Make all P fields that haven't already been constructed 0960 0961 0962 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0963 'Writes this packet to the supplied buffer' 0964 self._bufferstartoffset=buf.getcurrentoffset() 0965 self.__field_binary.writetobuffer(buf) 0966 self.__field_unknown3.writetobuffer(buf) 0967 self.__field_unknown4.writetobuffer(buf) 0968 self.__field_unknown6.writetobuffer(buf) 0969 self.__field_length.writetobuffer(buf) 0970 try: self.__field_msg 0971 except: 0972 self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx8500_114, 'length': 219}) 0973 self.__field_msg.writetobuffer(buf) 0974 self._bufferendoffset=buf.getcurrentoffset() 0975 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0976 0977 0978 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0979 'Reads this packet from the supplied buffer' 0980 self._bufferstartoffset=buf.getcurrentoffset() 0981 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0982 self.__field_binary=UINT(**{'sizeinbytes': 1}) 0983 self.__field_binary.readfrombuffer(buf) 0984 self.__field_unknown3=UINT(**{'sizeinbytes': 1}) 0985 self.__field_unknown3.readfrombuffer(buf) 0986 self.__field_unknown4=UINT(**{'sizeinbytes': 1}) 0987 self.__field_unknown4.readfrombuffer(buf) 0988 self.__field_unknown6=UINT(**{'sizeinbytes': 1}) 0989 self.__field_unknown6.readfrombuffer(buf) 0990 self.__field_length=UINT(**{'sizeinbytes': 1}) 0991 self.__field_length.readfrombuffer(buf) 0992 self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx8500_114, 'length': 219}) 0993 self.__field_msg.readfrombuffer(buf) 0994 self._bufferendoffset=buf.getcurrentoffset() 0995 0996 0997 def __getfield_binary(self): 0998 return self.__field_binary.getvalue() 0999 1000 def __setfield_binary(self, value): 1001 if isinstance(value,UINT): 1002 self.__field_binary=value 1003 else: 1004 self.__field_binary=UINT(value,**{'sizeinbytes': 1}) 1005 1006 def __delfield_binary(self): del self.__field_binary 1007 1008 binary=property(__getfield_binary, __setfield_binary, __delfield_binary, None) 1009 1010 def __getfield_unknown3(self): 1011 return self.__field_unknown3.getvalue() 1012 1013 def __setfield_unknown3(self, value): 1014 if isinstance(value,UINT): 1015 self.__field_unknown3=value 1016 else: 1017 self.__field_unknown3=UINT(value,**{'sizeinbytes': 1}) 1018 1019 def __delfield_unknown3(self): del self.__field_unknown3 1020 1021 unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None) 1022 1023 def __getfield_unknown4(self): 1024 return self.__field_unknown4.getvalue() 1025 1026 def __setfield_unknown4(self, value): 1027 if isinstance(value,UINT): 1028 self.__field_unknown4=value 1029 else: 1030 self.__field_unknown4=UINT(value,**{'sizeinbytes': 1}) 1031 1032 def __delfield_unknown4(self): del self.__field_unknown4 1033 1034 unknown4=property(__getfield_unknown4, __setfield_unknown4, __delfield_unknown4, None) 1035 1036 def __getfield_unknown6(self): 1037 return self.__field_unknown6.getvalue() 1038 1039 def __setfield_unknown6(self, value): 1040 if isinstance(value,UINT): 1041 self.__field_unknown6=value 1042 else: 1043 self.__field_unknown6=UINT(value,**{'sizeinbytes': 1}) 1044 1045 def __delfield_unknown6(self): del self.__field_unknown6 1046 1047 unknown6=property(__getfield_unknown6, __setfield_unknown6, __delfield_unknown6, None) 1048 1049 def __getfield_length(self): 1050 return self.__field_length.getvalue() 1051 1052 def __setfield_length(self, value): 1053 if isinstance(value,UINT): 1054 self.__field_length=value 1055 else: 1056 self.__field_length=UINT(value,**{'sizeinbytes': 1}) 1057 1058 def __delfield_length(self): del self.__field_length 1059 1060 length=property(__getfield_length, __setfield_length, __delfield_length, None) 1061 1062 def __getfield_msg(self): 1063 try: self.__field_msg 1064 except: 1065 self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx8500_114, 'length': 219}) 1066 return self.__field_msg.getvalue() 1067 1068 def __setfield_msg(self, value): 1069 if isinstance(value,LIST): 1070 self.__field_msg=value 1071 else: 1072 self.__field_msg=LIST(value,**{'elementclass': _gen_p_lgvx8500_114, 'length': 219}) 1073 1074 def __delfield_msg(self): del self.__field_msg 1075 1076 msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None) 1077 1078 def iscontainer(self): 1079 return True 1080 1081 def containerelements(self): 1082 yield ('binary', self.__field_binary, None) 1083 yield ('unknown3', self.__field_unknown3, None) 1084 yield ('unknown4', self.__field_unknown4, None) 1085 yield ('unknown6', self.__field_unknown6, None) 1086 yield ('length', self.__field_length, None) 1087 yield ('msg', self.__field_msg, None) 1088 1089 1090 1091 1092 class _gen_p_lgvx8500_114(BaseProtogenClass): 1093 'Anonymous inner class' 1094 __fields=['byte'] 1095 1096 def __init__(self, *args, **kwargs): 1097 dict={} 1098 # What was supplied to this function 1099 dict.update(kwargs) 1100 # Parent constructor 1101 super(_gen_p_lgvx8500_114,self).__init__(**dict) 1102 if self.__class__ is _gen_p_lgvx8500_114: 1103 self._update(args,dict) 1104 1105 1106 def getfields(self): 1107 return self.__fields 1108 1109 1110 def _update(self, args, kwargs): 1111 super(_gen_p_lgvx8500_114,self)._update(args,kwargs) 1112 keys=kwargs.keys() 1113 for key in keys: 1114 if key in self.__fields: 1115 setattr(self, key, kwargs[key]) 1116 del kwargs[key] 1117 # Were any unrecognized kwargs passed in? 1118 if __debug__: 1119 self._complainaboutunusedargs(_gen_p_lgvx8500_114,kwargs) 1120 if len(args): 1121 dict2={'sizeinbytes': 1} 1122 dict2.update(kwargs) 1123 kwargs=dict2 1124 self.__field_byte=UINT(*args,**dict2) 1125 # Make all P fields that haven't already been constructed 1126 1127 1128 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1129 'Writes this packet to the supplied buffer' 1130 self._bufferstartoffset=buf.getcurrentoffset() 1131 self.__field_byte.writetobuffer(buf) 1132 self._bufferendoffset=buf.getcurrentoffset() 1133 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1134 1135 1136 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1137 'Reads this packet from the supplied buffer' 1138 self._bufferstartoffset=buf.getcurrentoffset() 1139 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1140 self.__field_byte=UINT(**{'sizeinbytes': 1}) 1141 self.__field_byte.readfrombuffer(buf) 1142 self._bufferendoffset=buf.getcurrentoffset() 1143 1144 1145 def __getfield_byte(self): 1146 return self.__field_byte.getvalue() 1147 1148 def __setfield_byte(self, value): 1149 if isinstance(value,UINT): 1150 self.__field_byte=value 1151 else: 1152 self.__field_byte=UINT(value,**{'sizeinbytes': 1}) 1153 1154 def __delfield_byte(self): del self.__field_byte 1155 1156 byte=property(__getfield_byte, __setfield_byte, __delfield_byte, "individual byte of message") 1157 1158 def iscontainer(self): 1159 return True 1160 1161 def containerelements(self): 1162 yield ('byte', self.__field_byte, "individual byte of message") 1163 1164 1165 1166 1167 class recipient_record(BaseProtogenClass): 1168 __fields=['unknown1', 'number', 'status', 'dunno1', 'timesent', 'timereceived', 'unknown2', 'unknown3'] 1169 1170 def __init__(self, *args, **kwargs): 1171 dict={} 1172 # What was supplied to this function 1173 dict.update(kwargs) 1174 # Parent constructor 1175 super(recipient_record,self).__init__(**dict) 1176 if self.__class__ is recipient_record: 1177 self._update(args,dict) 1178 1179 1180 def getfields(self): 1181 return self.__fields 1182 1183 1184 def _update(self, args, kwargs): 1185 super(recipient_record,self)._update(args,kwargs) 1186 keys=kwargs.keys() 1187 for key in keys: 1188 if key in self.__fields: 1189 setattr(self, key, kwargs[key]) 1190 del kwargs[key] 1191 # Were any unrecognized kwargs passed in? 1192 if __debug__: 1193 self._complainaboutunusedargs(recipient_record,kwargs) 1194 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 1195 # Make all P fields that haven't already been constructed 1196 1197 1198 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1199 'Writes this packet to the supplied buffer' 1200 self._bufferstartoffset=buf.getcurrentoffset() 1201 self.__field_unknown1.writetobuffer(buf) 1202 self.__field_number.writetobuffer(buf) 1203 self.__field_status.writetobuffer(buf) 1204 self.__field_dunno1.writetobuffer(buf) 1205 self.__field_timesent.writetobuffer(buf) 1206 self.__field_timereceived.writetobuffer(buf) 1207 self.__field_unknown2.writetobuffer(buf) 1208 self.__field_unknown3.writetobuffer(buf) 1209 self._bufferendoffset=buf.getcurrentoffset() 1210 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1211 1212 1213 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1214 'Reads this packet from the supplied buffer' 1215 self._bufferstartoffset=buf.getcurrentoffset() 1216 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1217 self.__field_unknown1=DATA(**{'sizeinbytes': 33}) 1218 self.__field_unknown1.readfrombuffer(buf) 1219 self.__field_number=USTRING(**{'sizeinbytes': 50}) 1220 self.__field_number.readfrombuffer(buf) 1221 self.__field_status=UINT(**{'sizeinbytes': 1}) 1222 self.__field_status.readfrombuffer(buf) 1223 self.__field_dunno1=UNKNOWN(**{'sizeinbytes': 3}) 1224 self.__field_dunno1.readfrombuffer(buf) 1225 self.__field_timesent=LGCALDATE(**{'sizeinbytes': 4}) 1226 self.__field_timesent.readfrombuffer(buf) 1227 self.__field_timereceived=LGCALDATE(**{'sizeinbytes': 4}) 1228 self.__field_timereceived.readfrombuffer(buf) 1229 self.__field_unknown2=UINT(**{'sizeinbytes': 1}) 1230 self.__field_unknown2.readfrombuffer(buf) 1231 self.__field_unknown3=DATA(**{'sizeinbytes': 57}) 1232 self.__field_unknown3.readfrombuffer(buf) 1233 self._bufferendoffset=buf.getcurrentoffset() 1234 1235 1236 def __getfield_unknown1(self): 1237 return self.__field_unknown1.getvalue() 1238 1239 def __setfield_unknown1(self, value): 1240 if isinstance(value,DATA): 1241 self.__field_unknown1=value 1242 else: 1243 self.__field_unknown1=DATA(value,**{'sizeinbytes': 33}) 1244 1245 def __delfield_unknown1(self): del self.__field_unknown1 1246 1247 unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 1248 1249 def __getfield_number(self): 1250 return self.__field_number.getvalue() 1251 1252 def __setfield_number(self, value): 1253 if isinstance(value,USTRING): 1254 self.__field_number=value 1255 else: 1256 self.__field_number=USTRING(value,**{'sizeinbytes': 50}) 1257 1258 def __delfield_number(self): del self.__field_number 1259 1260 number=property(__getfield_number, __setfield_number, __delfield_number, None) 1261 1262 def __getfield_status(self): 1263 return self.__field_status.getvalue() 1264 1265 def __setfield_status(self, value): 1266 if isinstance(value,UINT): 1267 self.__field_status=value 1268 else: 1269 self.__field_status=UINT(value,**{'sizeinbytes': 1}) 1270 1271 def __delfield_status(self): del self.__field_status 1272 1273 status=property(__getfield_status, __setfield_status, __delfield_status, None) 1274 1275 def __getfield_dunno1(self): 1276 return self.__field_dunno1.getvalue() 1277 1278 def __setfield_dunno1(self, value): 1279 if isinstance(value,UNKNOWN): 1280 self.__field_dunno1=value 1281 else: 1282 self.__field_dunno1=UNKNOWN(value,**{'sizeinbytes': 3}) 1283 1284 def __delfield_dunno1(self): del self.__field_dunno1 1285 1286 dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None) 1287 1288 def __getfield_timesent(self): 1289 return self.__field_timesent.getvalue() 1290 1291 def __setfield_timesent(self, value): 1292 if isinstance(value,LGCALDATE): 1293 self.__field_timesent=value 1294 else: 1295 self.__field_timesent=LGCALDATE(value,**{'sizeinbytes': 4}) 1296 1297 def __delfield_timesent(self): del self.__field_timesent 1298 1299 timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None) 1300 1301 def __getfield_timereceived(self): 1302 return self.__field_timereceived.getvalue() 1303 1304 def __setfield_timereceived(self, value): 1305 if isinstance(value,LGCALDATE): 1306 self.__field_timereceived=value 1307 else: 1308 self.__field_timereceived=LGCALDATE(value,**{'sizeinbytes': 4}) 1309 1310 def __delfield_timereceived(self): del self.__field_timereceived 1311 1312 timereceived=property(__getfield_timereceived, __setfield_timereceived, __delfield_timereceived, None) 1313 1314 def __getfield_unknown2(self): 1315 return self.__field_unknown2.getvalue() 1316 1317 def __setfield_unknown2(self, value): 1318 if isinstance(value,UINT): 1319 self.__field_unknown2=value 1320 else: 1321 self.__field_unknown2=UINT(value,**{'sizeinbytes': 1}) 1322 1323 def __delfield_unknown2(self): del self.__field_unknown2 1324 1325 unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None) 1326 1327 def __getfield_unknown3(self): 1328 return self.__field_unknown3.getvalue() 1329 1330 def __setfield_unknown3(self, value): 1331 if isinstance(value,DATA): 1332 self.__field_unknown3=value 1333 else: 1334 self.__field_unknown3=DATA(value,**{'sizeinbytes': 57}) 1335 1336 def __delfield_unknown3(self): del self.__field_unknown3 1337 1338 unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None) 1339 1340 def iscontainer(self): 1341 return True 1342 1343 def containerelements(self): 1344 yield ('unknown1', self.__field_unknown1, None) 1345 yield ('number', self.__field_number, None) 1346 yield ('status', self.__field_status, None) 1347 yield ('dunno1', self.__field_dunno1, None) 1348 yield ('timesent', self.__field_timesent, None) 1349 yield ('timereceived', self.__field_timereceived, None) 1350 yield ('unknown2', self.__field_unknown2, None) 1351 yield ('unknown3', self.__field_unknown3, None) 1352 1353 1354 1355 1356 class sms_saved(BaseProtogenClass): 1357 __fields=['outboxmsg', 'GPStime', 'outbox'] 1358 1359 def __init__(self, *args, **kwargs): 1360 dict={} 1361 # What was supplied to this function 1362 dict.update(kwargs) 1363 # Parent constructor 1364 super(sms_saved,self).__init__(**dict) 1365 if self.__class__ is sms_saved: 1366 self._update(args,dict) 1367 1368 1369 def getfields(self): 1370 return self.__fields 1371 1372 1373 def _update(self, args, kwargs): 1374 super(sms_saved,self)._update(args,kwargs) 1375 keys=kwargs.keys() 1376 for key in keys: 1377 if key in self.__fields: 1378 setattr(self, key, kwargs[key]) 1379 del kwargs[key] 1380 # Were any unrecognized kwargs passed in? 1381 if __debug__: 1382 self._complainaboutunusedargs(sms_saved,kwargs) 1383 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 1384 # Make all P fields that haven't already been constructed 1385 try: self.__field_outboxmsg 1386 except: 1387 self.__field_outboxmsg=BOOL(**{ 'default': True }) 1388 1389 1390 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1391 'Writes this packet to the supplied buffer' 1392 self._bufferstartoffset=buf.getcurrentoffset() 1393 self.__field_GPStime.writetobuffer(buf) 1394 self.__field_outbox.writetobuffer(buf) 1395 self._bufferendoffset=buf.getcurrentoffset() 1396 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1397 1398 1399 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1400 'Reads this packet from the supplied buffer' 1401 self._bufferstartoffset=buf.getcurrentoffset() 1402 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1403 self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4}) 1404 self.__field_GPStime.readfrombuffer(buf) 1405 self.__field_outbox=sms_out() 1406 self.__field_outbox.readfrombuffer(buf) 1407 self._bufferendoffset=buf.getcurrentoffset() 1408 1409 1410 def __getfield_outboxmsg(self): 1411 try: self.__field_outboxmsg 1412 except: 1413 self.__field_outboxmsg=BOOL(**{ 'default': True }) 1414 return self.__field_outboxmsg.getvalue() 1415 1416 def __setfield_outboxmsg(self, value): 1417 if isinstance(value,BOOL): 1418 self.__field_outboxmsg=value 1419 else: 1420 self.__field_outboxmsg=BOOL(value,**{ 'default': True }) 1421 1422 def __delfield_outboxmsg(self): del self.__field_outboxmsg 1423 1424 outboxmsg=property(__getfield_outboxmsg, __setfield_outboxmsg, __delfield_outboxmsg, None) 1425 1426 def __getfield_GPStime(self): 1427 return self.__field_GPStime.getvalue() 1428 1429 def __setfield_GPStime(self, value): 1430 if isinstance(value,GPSDATE): 1431 self.__field_GPStime=value 1432 else: 1433 self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4}) 1434 1435 def __delfield_GPStime(self): del self.__field_GPStime 1436 1437 GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None) 1438 1439 def __getfield_outbox(self): 1440 return self.__field_outbox.getvalue() 1441 1442 def __setfield_outbox(self, value): 1443 if isinstance(value,sms_out): 1444 self.__field_outbox=value 1445 else: 1446 self.__field_outbox=sms_out(value,) 1447 1448 def __delfield_outbox(self): del self.__field_outbox 1449 1450 outbox=property(__getfield_outbox, __setfield_outbox, __delfield_outbox, None) 1451 1452 def iscontainer(self): 1453 return True 1454 1455 def containerelements(self): 1456 yield ('outboxmsg', self.__field_outboxmsg, None) 1457 yield ('GPStime', self.__field_GPStime, None) 1458 yield ('outbox', self.__field_outbox, None) 1459 1460 1461 1462 1463 class sms_out(BaseProtogenClass): 1464 __fields=['index', 'locked', 'timesent', 'unknown2', 'subject', 'num_msg_elements', 'messages', 'unknown1', 'priority', 'unknown5', 'callback', 'recipients', 'pad'] 1465 1466 def __init__(self, *args, **kwargs): 1467 dict={} 1468 # What was supplied to this function 1469 dict.update(kwargs) 1470 # Parent constructor 1471 super(sms_out,self).__init__(**dict) 1472 if self.__class__ is sms_out: 1473 self._update(args,dict) 1474 1475 1476 def getfields(self): 1477 return self.__fields 1478 1479 1480 def _update(self, args, kwargs): 1481 super(sms_out,self)._update(args,kwargs) 1482 keys=kwargs.keys() 1483 for key in keys: 1484 if key in self.__fields: 1485 setattr(self, key, kwargs[key]) 1486 del kwargs[key] 1487 # Were any unrecognized kwargs passed in? 1488 if __debug__: 1489 self._complainaboutunusedargs(sms_out,kwargs) 1490 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 1491 # Make all P fields that haven't already been constructed 1492 1493 1494 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1495 'Writes this packet to the supplied buffer' 1496 self._bufferstartoffset=buf.getcurrentoffset() 1497 self.__field_index.writetobuffer(buf) 1498 self.__field_locked.writetobuffer(buf) 1499 self.__field_timesent.writetobuffer(buf) 1500 self.__field_unknown2.writetobuffer(buf) 1501 self.__field_subject.writetobuffer(buf) 1502 self.__field_num_msg_elements.writetobuffer(buf) 1503 try: self.__field_messages 1504 except: 1505 self.__field_messages=LIST(**{'elementclass': msg_record, 'length': 7}) 1506 self.__field_messages.writetobuffer(buf) 1507 self.__field_unknown1.writetobuffer(buf) 1508 self.__field_priority.writetobuffer(buf) 1509 self.__field_unknown5.writetobuffer(buf) 1510 self.__field_callback.writetobuffer(buf) 1511 try: self.__field_recipients 1512 except: 1513 self.__field_recipients=LIST(**{'elementclass': recipient_record,'length': 9}) 1514 self.__field_recipients.writetobuffer(buf) 1515 self.__field_pad.writetobuffer(buf) 1516 self._bufferendoffset=buf.getcurrentoffset() 1517 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1518 1519 1520 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1521 'Reads this packet from the supplied buffer' 1522 self._bufferstartoffset=buf.getcurrentoffset() 1523 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1524 self.__field_index=UINT(**{'sizeinbytes': 4}) 1525 self.__field_index.readfrombuffer(buf) 1526 self.__field_locked=UINT(**{'sizeinbytes': 1}) 1527 self.__field_locked.readfrombuffer(buf) 1528 self.__field_timesent=LGCALDATE(**{'sizeinbytes': 4}) 1529 self.__field_timesent.readfrombuffer(buf) 1530 self.__field_unknown2=UNKNOWN(**{'sizeinbytes': 7}) 1531 self.__field_unknown2.readfrombuffer(buf) 1532 self.__field_subject=USTRING(**{'sizeinbytes': 61, 'encoding': PHONE_ENCODING}) 1533 self.__field_subject.readfrombuffer(buf) 1534 self.__field_num_msg_elements=UINT(**{'sizeinbytes': 1}) 1535 self.__field_num_msg_elements.readfrombuffer(buf) 1536 self.__field_messages=LIST(**{'elementclass': msg_record, 'length': 7}) 1537 self.__field_messages.readfrombuffer(buf) 1538 self.__field_unknown1=UNKNOWN(**{'sizeinbytes': 8}) 1539 self.__field_unknown1.readfrombuffer(buf) 1540 self.__field_priority=UINT(**{'sizeinbytes': 1}) 1541 self.__field_priority.readfrombuffer(buf) 1542 self.__field_unknown5=UNKNOWN(**{'sizeinbytes': 16}) 1543 self.__field_unknown5.readfrombuffer(buf) 1544 self.__field_callback=USTRING(**{'sizeinbytes': 73}) 1545 self.__field_callback.readfrombuffer(buf) 1546 self.__field_recipients=LIST(**{'elementclass': recipient_record,'length': 9}) 1547 self.__field_recipients.readfrombuffer(buf) 1548 self.__field_pad=UNKNOWN() 1549 self.__field_pad.readfrombuffer(buf) 1550 self._bufferendoffset=buf.getcurrentoffset() 1551 1552 1553 def __getfield_index(self): 1554 return self.__field_index.getvalue() 1555 1556 def __setfield_index(self, value): 1557 if isinstance(value,UINT): 1558 self.__field_index=value 1559 else: 1560 self.__field_index=UINT(value,**{'sizeinbytes': 4}) 1561 1562 def __delfield_index(self): del self.__field_index 1563 1564 index=property(__getfield_index, __setfield_index, __delfield_index, None) 1565 1566 def __getfield_locked(self): 1567 return self.__field_locked.getvalue() 1568 1569 def __setfield_locked(self, value): 1570 if isinstance(value,UINT): 1571 self.__field_locked=value 1572 else: 1573 self.__field_locked=UINT(value,**{'sizeinbytes': 1}) 1574 1575 def __delfield_locked(self): del self.__field_locked 1576 1577 locked=property(__getfield_locked, __setfield_locked, __delfield_locked, None) 1578 1579 def __getfield_timesent(self): 1580 return self.__field_timesent.getvalue() 1581 1582 def __setfield_timesent(self, value): 1583 if isinstance(value,LGCALDATE): 1584 self.__field_timesent=value 1585 else: 1586 self.__field_timesent=LGCALDATE(value,**{'sizeinbytes': 4}) 1587 1588 def __delfield_timesent(self): del self.__field_timesent 1589 1590 timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None) 1591 1592 def __getfield_unknown2(self): 1593 return self.__field_unknown2.getvalue() 1594 1595 def __setfield_unknown2(self, value): 1596 if isinstance(value,UNKNOWN): 1597 self.__field_unknown2=value 1598 else: 1599 self.__field_unknown2=UNKNOWN(value,**{'sizeinbytes': 7}) 1600 1601 def __delfield_unknown2(self): del self.__field_unknown2 1602 1603 unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None) 1604 1605 def __getfield_subject(self): 1606 return self.__field_subject.getvalue() 1607 1608 def __setfield_subject(self, value): 1609 if isinstance(value,USTRING): 1610 self.__field_subject=value 1611 else: 1612 self.__field_subject=USTRING(value,**{'sizeinbytes': 61, 'encoding': PHONE_ENCODING}) 1613 1614 def __delfield_subject(self): del self.__field_subject 1615 1616 subject=property(__getfield_subject, __setfield_subject, __delfield_subject, None) 1617 1618 def __getfield_num_msg_elements(self): 1619 return self.__field_num_msg_elements.getvalue() 1620 1621 def __setfield_num_msg_elements(self, value): 1622 if isinstance(value,UINT): 1623 self.__field_num_msg_elements=value 1624 else: 1625 self.__field_num_msg_elements=UINT(value,**{'sizeinbytes': 1}) 1626 1627 def __delfield_num_msg_elements(self): del self.__field_num_msg_elements 1628 1629 num_msg_elements=property(__getfield_num_msg_elements, __setfield_num_msg_elements, __delfield_num_msg_elements, None) 1630 1631 def __getfield_messages(self): 1632 try: self.__field_messages 1633 except: 1634 self.__field_messages=LIST(**{'elementclass': msg_record, 'length': 7}) 1635 return self.__field_messages.getvalue() 1636 1637 def __setfield_messages(self, value): 1638 if isinstance(value,LIST): 1639 self.__field_messages=value 1640 else: 1641 self.__field_messages=LIST(value,**{'elementclass': msg_record, 'length': 7}) 1642 1643 def __delfield_messages(self): del self.__field_messages 1644 1645 messages=property(__getfield_messages, __setfield_messages, __delfield_messages, None) 1646 1647 def __getfield_unknown1(self): 1648 return self.__field_unknown1.getvalue() 1649 1650 def __setfield_unknown1(self, value): 1651 if isinstance(value,UNKNOWN): 1652 self.__field_unknown1=value 1653 else: 1654 self.__field_unknown1=UNKNOWN(value,**{'sizeinbytes': 8}) 1655 1656 def __delfield_unknown1(self): del self.__field_unknown1 1657 1658 unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 1659 1660 def __getfield_priority(self): 1661 return self.__field_priority.getvalue() 1662 1663 def __setfield_priority(self, value): 1664 if isinstance(value,UINT): 1665 self.__field_priority=value 1666 else: 1667 self.__field_priority=UINT(value,**{'sizeinbytes': 1}) 1668 1669 def __delfield_priority(self): del self.__field_priority 1670 1671 priority=property(__getfield_priority, __setfield_priority, __delfield_priority, None) 1672 1673 def __getfield_unknown5(self): 1674 return self.__field_unknown5.getvalue() 1675 1676 def __setfield_unknown5(self, value): 1677 if isinstance(value,UNKNOWN): 1678 self.__field_unknown5=value 1679 else: 1680 self.__field_unknown5=UNKNOWN(value,**{'sizeinbytes': 16}) 1681 1682 def __delfield_unknown5(self): del self.__field_unknown5 1683 1684 unknown5=property(__getfield_unknown5, __setfield_unknown5, __delfield_unknown5, None) 1685 1686 def __getfield_callback(self): 1687 return self.__field_callback.getvalue() 1688 1689 def __setfield_callback(self, value): 1690 if isinstance(value,USTRING): 1691 self.__field_callback=value 1692 else: 1693 self.__field_callback=USTRING(value,**{'sizeinbytes': 73}) 1694 1695 def __delfield_callback(self): del self.__field_callback 1696 1697 callback=property(__getfield_callback, __setfield_callback, __delfield_callback, None) 1698 1699 def __getfield_recipients(self): 1700 try: self.__field_recipients 1701 except: 1702 self.__field_recipients=LIST(**{'elementclass': recipient_record,'length': 9}) 1703 return self.__field_recipients.getvalue() 1704 1705 def __setfield_recipients(self, value): 1706 if isinstance(value,LIST): 1707 self.__field_recipients=value 1708 else: 1709 self.__field_recipients=LIST(value,**{'elementclass': recipient_record,'length': 9}) 1710 1711 def __delfield_recipients(self): del self.__field_recipients 1712 1713 recipients=property(__getfield_recipients, __setfield_recipients, __delfield_recipients, None) 1714 1715 def __getfield_pad(self): 1716 return self.__field_pad.getvalue() 1717 1718 def __setfield_pad(self, value): 1719 if isinstance(value,UNKNOWN): 1720 self.__field_pad=value 1721 else: 1722 self.__field_pad=UNKNOWN(value,) 1723 1724 def __delfield_pad(self): del self.__field_pad 1725 1726 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 1727 1728 def iscontainer(self): 1729 return True 1730 1731 def containerelements(self): 1732 yield ('index', self.__field_index, None) 1733 yield ('locked', self.__field_locked, None) 1734 yield ('timesent', self.__field_timesent, None) 1735 yield ('unknown2', self.__field_unknown2, None) 1736 yield ('subject', self.__field_subject, None) 1737 yield ('num_msg_elements', self.__field_num_msg_elements, None) 1738 yield ('messages', self.__field_messages, None) 1739 yield ('unknown1', self.__field_unknown1, None) 1740 yield ('priority', self.__field_priority, None) 1741 yield ('unknown5', self.__field_unknown5, None) 1742 yield ('callback', self.__field_callback, None) 1743 yield ('recipients', self.__field_recipients, None) 1744 yield ('pad', self.__field_pad, None) 1745 1746 1747 1748 1749 class SMSINBOXMSGFRAGMENT(BaseProtogenClass): 1750 __fields=['msg'] 1751 1752 def __init__(self, *args, **kwargs): 1753 dict={} 1754 # What was supplied to this function 1755 dict.update(kwargs) 1756 # Parent constructor 1757 super(SMSINBOXMSGFRAGMENT,self).__init__(**dict) 1758 if self.__class__ is SMSINBOXMSGFRAGMENT: 1759 self._update(args,dict) 1760 1761 1762 def getfields(self): 1763 return self.__fields 1764 1765 1766 def _update(self, args, kwargs): 1767 super(SMSINBOXMSGFRAGMENT,self)._update(args,kwargs) 1768 keys=kwargs.keys() 1769 for key in keys: 1770 if key in self.__fields: 1771 setattr(self, key, kwargs[key]) 1772 del kwargs[key] 1773 # Were any unrecognized kwargs passed in? 1774 if __debug__: 1775 self._complainaboutunusedargs(SMSINBOXMSGFRAGMENT,kwargs) 1776 if len(args): 1777 dict2={'elementclass': _gen_p_lgvx8500_148, 'length': 181} 1778 dict2.update(kwargs) 1779 kwargs=dict2 1780 self.__field_msg=LIST(*args,**dict2) 1781 # Make all P fields that haven't already been constructed 1782 1783 1784 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1785 'Writes this packet to the supplied buffer' 1786 self._bufferstartoffset=buf.getcurrentoffset() 1787 try: self.__field_msg 1788 except: 1789 self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx8500_148, 'length': 181}) 1790 self.__field_msg.writetobuffer(buf) 1791 self._bufferendoffset=buf.getcurrentoffset() 1792 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1793 1794 1795 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1796 'Reads this packet from the supplied buffer' 1797 self._bufferstartoffset=buf.getcurrentoffset() 1798 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1799 self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx8500_148, 'length': 181}) 1800 self.__field_msg.readfrombuffer(buf) 1801 self._bufferendoffset=buf.getcurrentoffset() 1802 1803 1804 def __getfield_msg(self): 1805 try: self.__field_msg 1806 except: 1807 self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx8500_148, 'length': 181}) 1808 return self.__field_msg.getvalue() 1809 1810 def __setfield_msg(self, value): 1811 if isinstance(value,LIST): 1812 self.__field_msg=value 1813 else: 1814 self.__field_msg=LIST(value,**{'elementclass': _gen_p_lgvx8500_148, 'length': 181}) 1815 1816 def __delfield_msg(self): del self.__field_msg 1817 1818 msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None) 1819 1820 def iscontainer(self): 1821 return True 1822 1823 def containerelements(self): 1824 yield ('msg', self.__field_msg, None) 1825 1826 1827 1828 1829 class _gen_p_lgvx8500_148(BaseProtogenClass): 1830 'Anonymous inner class' 1831 __fields=['byte'] 1832 1833 def __init__(self, *args, **kwargs): 1834 dict={} 1835 # What was supplied to this function 1836 dict.update(kwargs) 1837 # Parent constructor 1838 super(_gen_p_lgvx8500_148,self).__init__(**dict) 1839 if self.__class__ is _gen_p_lgvx8500_148: 1840 self._update(args,dict) 1841 1842 1843 def getfields(self): 1844 return self.__fields 1845 1846 1847 def _update(self, args, kwargs): 1848 super(_gen_p_lgvx8500_148,self)._update(args,kwargs) 1849 keys=kwargs.keys() 1850 for key in keys: 1851 if key in self.__fields: 1852 setattr(self, key, kwargs[key]) 1853 del kwargs[key] 1854 # Were any unrecognized kwargs passed in? 1855 if __debug__: 1856 self._complainaboutunusedargs(_gen_p_lgvx8500_148,kwargs) 1857 if len(args): 1858 dict2={'sizeinbytes': 1} 1859 dict2.update(kwargs) 1860 kwargs=dict2 1861 self.__field_byte=UINT(*args,**dict2) 1862 # Make all P fields that haven't already been constructed 1863 1864 1865 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1866 'Writes this packet to the supplied buffer' 1867 self._bufferstartoffset=buf.getcurrentoffset() 1868 self.__field_byte.writetobuffer(buf) 1869 self._bufferendoffset=buf.getcurrentoffset() 1870 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1871 1872 1873 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1874 'Reads this packet from the supplied buffer' 1875 self._bufferstartoffset=buf.getcurrentoffset() 1876 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1877 self.__field_byte=UINT(**{'sizeinbytes': 1}) 1878 self.__field_byte.readfrombuffer(buf) 1879 self._bufferendoffset=buf.getcurrentoffset() 1880 1881 1882 def __getfield_byte(self): 1883 return self.__field_byte.getvalue() 1884 1885 def __setfield_byte(self, value): 1886 if isinstance(value,UINT): 1887 self.__field_byte=value 1888 else: 1889 self.__field_byte=UINT(value,**{'sizeinbytes': 1}) 1890 1891 def __delfield_byte(self): del self.__field_byte 1892 1893 byte=property(__getfield_byte, __setfield_byte, __delfield_byte, "individual byte of message") 1894 1895 def iscontainer(self): 1896 return True 1897 1898 def containerelements(self): 1899 yield ('byte', self.__field_byte, "individual byte of message") 1900 1901 1902 1903 1904 class sms_in(BaseProtogenClass): 1905 __fields=['unknown1', 'lg_time', 'unknown2', 'GPStime', 'timesent', 'read', 'locked', 'priority', 'dunno1', 'subject', 'dunno2', 'num_msg_elements', 'msglengths', 'unknown9', 'msgs', 'dunno3', 'sender_length', 'sender', 'dunno4', 'callback_length', 'callback', 'PAD', 'bin_header1', 'bin_header2', 'multipartID', 'bin_header3'] 1906 1907 def __init__(self, *args, **kwargs): 1908 dict={} 1909 # What was supplied to this function 1910 dict.update(kwargs) 1911 # Parent constructor 1912 super(sms_in,self).__init__(**dict) 1913 if self.__class__ is sms_in: 1914 self._update(args,dict) 1915 1916 1917 def getfields(self): 1918 return self.__fields 1919 1920 1921 def _update(self, args, kwargs): 1922 super(sms_in,self)._update(args,kwargs) 1923 keys=kwargs.keys() 1924 for key in keys: 1925 if key in self.__fields: 1926 setattr(self, key, kwargs[key]) 1927 del kwargs[key] 1928 # Were any unrecognized kwargs passed in? 1929 if __debug__: 1930 self._complainaboutunusedargs(sms_in,kwargs) 1931 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 1932 # Make all P fields that haven't already been constructed 1933 try: self.__field_bin_header1 1934 except: 1935 self.__field_bin_header1=UINT(**{ 'default': 0 }) 1936 try: self.__field_bin_header2 1937 except: 1938 self.__field_bin_header2=UINT(**{ 'default': 0 }) 1939 try: self.__field_multipartID 1940 except: 1941 self.__field_multipartID=UINT(**{ 'default': 0 }) 1942 try: self.__field_bin_header3 1943 except: 1944 self.__field_bin_header3=UINT(**{ 'default': 0 }) 1945 1946 1947 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1948 'Writes this packet to the supplied buffer' 1949 self._bufferstartoffset=buf.getcurrentoffset() 1950 self.__field_unknown1.writetobuffer(buf) 1951 self.__field_lg_time.writetobuffer(buf) 1952 self.__field_unknown2.writetobuffer(buf) 1953 self.__field_GPStime.writetobuffer(buf) 1954 self.__field_timesent.writetobuffer(buf) 1955 self.__field_read.writetobuffer(buf) 1956 self.__field_locked.writetobuffer(buf) 1957 self.__field_priority.writetobuffer(buf) 1958 self.__field_dunno1.writetobuffer(buf) 1959 self.__field_subject.writetobuffer(buf) 1960 self.__field_dunno2.writetobuffer(buf) 1961 self.__field_num_msg_elements.writetobuffer(buf) 1962 try: self.__field_msglengths 1963 except: 1964 self.__field_msglengths=LIST(**{'elementclass': _gen_p_lgvx8500_165, 'length': 10}) 1965 self.__field_msglengths.writetobuffer(buf) 1966 self.__field_unknown9.writetobuffer(buf) 1967 try: self.__field_msgs 1968 except: 1969 self.__field_msgs=LIST(**{'length': 10, 'elementclass': SMSINBOXMSGFRAGMENT}) 1970 self.__field_msgs.writetobuffer(buf) 1971 self.__field_dunno3.writetobuffer(buf) 1972 self.__field_sender_length.writetobuffer(buf) 1973 try: self.__field_sender 1974 except: 1975 self.__field_sender=LIST(**{'elementclass': _gen_p_lgvx8500_171, 'length': 49}) 1976 self.__field_sender.writetobuffer(buf) 1977 self.__field_dunno4.writetobuffer(buf) 1978 self.__field_callback_length.writetobuffer(buf) 1979 self.__field_callback.writetobuffer(buf) 1980 self.__field_PAD.writetobuffer(buf) 1981 self._bufferendoffset=buf.getcurrentoffset() 1982 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1983 1984 1985 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1986 'Reads this packet from the supplied buffer' 1987 self._bufferstartoffset=buf.getcurrentoffset() 1988 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1989 self.__field_unknown1=UNKNOWN(**{'sizeinbytes': 7}) 1990 self.__field_unknown1.readfrombuffer(buf) 1991 self.__field_lg_time=LGCALDATE(**{'sizeinbytes': 4}) 1992 self.__field_lg_time.readfrombuffer(buf) 1993 self.__field_unknown2=UINT(**{'sizeinbytes': 1}) 1994 self.__field_unknown2.readfrombuffer(buf) 1995 self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4}) 1996 self.__field_GPStime.readfrombuffer(buf) 1997 self.__field_timesent=SMSDATE(**{'sizeinbytes': 6}) 1998 self.__field_timesent.readfrombuffer(buf) 1999 self.__field_read=UINT(**{'sizeinbytes': 1}) 2000 self.__field_read.readfrombuffer(buf) 2001 self.__field_locked=UINT(**{'sizeinbytes': 1}) 2002 self.__field_locked.readfrombuffer(buf) 2003 self.__field_priority=UINT(**{'sizeinbytes': 1}) 2004 self.__field_priority.readfrombuffer(buf) 2005 self.__field_dunno1=UNKNOWN(**{'sizeinbytes': 6}) 2006 self.__field_dunno1.readfrombuffer(buf) 2007 self.__field_subject=USTRING(**{'sizeinbytes': 23, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False }) 2008 self.__field_subject.readfrombuffer(buf) 2009 self.__field_dunno2=UNKNOWN(**{'sizeinbytes': 47}) 2010 self.__field_dunno2.readfrombuffer(buf) 2011 self.__field_num_msg_elements=UINT(**{'sizeinbytes': 1}) 2012 self.__field_num_msg_elements.readfrombuffer(buf) 2013 self.__field_msglengths=LIST(**{'elementclass': _gen_p_lgvx8500_165, 'length': 10}) 2014 self.__field_msglengths.readfrombuffer(buf) 2015 self.__field_unknown9=UNKNOWN(**{'sizeinbytes': 10}) 2016 self.__field_unknown9.readfrombuffer(buf) 2017 self.__field_msgs=LIST(**{'length': 10, 'elementclass': SMSINBOXMSGFRAGMENT}) 2018 self.__field_msgs.readfrombuffer(buf) 2019 self.__field_dunno3=UNKNOWN(**{'sizeinbytes': 2594}) 2020 self.__field_dunno3.readfrombuffer(buf) 2021 self.__field_sender_length=UINT(**{'sizeinbytes': 1}) 2022 self.__field_sender_length.readfrombuffer(buf) 2023 self.__field_sender=LIST(**{'elementclass': _gen_p_lgvx8500_171, 'length': 49}) 2024 self.__field_sender.readfrombuffer(buf) 2025 self.__field_dunno4=UNKNOWN(**{'sizeinbytes': 3}) 2026 self.__field_dunno4.readfrombuffer(buf) 2027 self.__field_callback_length=UINT(**{'sizeinbytes': 1}) 2028 self.__field_callback_length.readfrombuffer(buf) 2029 self.__field_callback=USTRING(**{'sizeinbytes': 55}) 2030 self.__field_callback.readfrombuffer(buf) 2031 self.__field_PAD=UNKNOWN() 2032 self.__field_PAD.readfrombuffer(buf) 2033 self._bufferendoffset=buf.getcurrentoffset() 2034 2035 2036 def __getfield_unknown1(self): 2037 return self.__field_unknown1.getvalue() 2038 2039 def __setfield_unknown1(self, value): 2040 if isinstance(value,UNKNOWN): 2041 self.__field_unknown1=value 2042 else: 2043 self.__field_unknown1=UNKNOWN(value,**{'sizeinbytes': 7}) 2044 2045 def __delfield_unknown1(self): del self.__field_unknown1 2046 2047 unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 2048 2049 def __getfield_lg_time(self): 2050 return self.__field_lg_time.getvalue() 2051 2052 def __setfield_lg_time(self, value): 2053 if isinstance(value,LGCALDATE): 2054 self.__field_lg_time=value 2055 else: 2056 self.__field_lg_time=LGCALDATE(value,**{'sizeinbytes': 4}) 2057 2058 def __delfield_lg_time(self): del self.__field_lg_time 2059 2060 lg_time=property(__getfield_lg_time, __setfield_lg_time, __delfield_lg_time, None) 2061 2062 def __getfield_unknown2(self): 2063 return self.__field_unknown2.getvalue() 2064 2065 def __setfield_unknown2(self, value): 2066 if isinstance(value,UINT): 2067 self.__field_unknown2=value 2068 else: 2069 self.__field_unknown2=UINT(value,**{'sizeinbytes': 1}) 2070 2071 def __delfield_unknown2(self): del self.__field_unknown2 2072 2073 unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None) 2074 2075 def __getfield_GPStime(self): 2076 return self.__field_GPStime.getvalue() 2077 2078 def __setfield_GPStime(self, value): 2079 if isinstance(value,GPSDATE): 2080 self.__field_GPStime=value 2081 else: 2082 self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4}) 2083 2084 def __delfield_GPStime(self): del self.__field_GPStime 2085 2086 GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None) 2087 2088 def __getfield_timesent(self): 2089 return self.__field_timesent.getvalue() 2090 2091 def __setfield_timesent(self, value): 2092 if isinstance(value,SMSDATE): 2093 self.__field_timesent=value 2094 else: 2095 self.__field_timesent=SMSDATE(value,**{'sizeinbytes': 6}) 2096 2097 def __delfield_timesent(self): del self.__field_timesent 2098 2099 timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None) 2100 2101 def __getfield_read(self): 2102 return self.__field_read.getvalue() 2103 2104 def __setfield_read(self, value): 2105 if isinstance(value,UINT): 2106 self.__field_read=value 2107 else: 2108 self.__field_read=UINT(value,**{'sizeinbytes': 1}) 2109 2110 def __delfield_read(self): del self.__field_read 2111 2112 read=property(__getfield_read, __setfield_read, __delfield_read, None) 2113 2114 def __getfield_locked(self): 2115 return self.__field_locked.getvalue() 2116 2117 def __setfield_locked(self, value): 2118 if isinstance(value,UINT): 2119 self.__field_locked=value 2120 else: 2121 self.__field_locked=UINT(value,**{'sizeinbytes': 1}) 2122 2123 def __delfield_locked(self): del self.__field_locked 2124 2125 locked=property(__getfield_locked, __setfield_locked, __delfield_locked, None) 2126 2127 def __getfield_priority(self): 2128 return self.__field_priority.getvalue() 2129 2130 def __setfield_priority(self, value): 2131 if isinstance(value,UINT): 2132 self.__field_priority=value 2133 else: 2134 self.__field_priority=UINT(value,**{'sizeinbytes': 1}) 2135 2136 def __delfield_priority(self): del self.__field_priority 2137 2138 priority=property(__getfield_priority, __setfield_priority, __delfield_priority, None) 2139 2140 def __getfield_dunno1(self): 2141 return self.__field_dunno1.getvalue() 2142 2143 def __setfield_dunno1(self, value): 2144 if isinstance(value,UNKNOWN): 2145 self.__field_dunno1=value 2146 else: 2147 self.__field_dunno1=UNKNOWN(value,**{'sizeinbytes': 6}) 2148 2149 def __delfield_dunno1(self): del self.__field_dunno1 2150 2151 dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None) 2152 2153 def __getfield_subject(self): 2154 return self.__field_subject.getvalue() 2155 2156 def __setfield_subject(self, value): 2157 if isinstance(value,USTRING): 2158 self.__field_subject=value 2159 else: 2160 self.__field_subject=USTRING(value,**{'sizeinbytes': 23, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False }) 2161 2162 def __delfield_subject(self): del self.__field_subject 2163 2164 subject=property(__getfield_subject, __setfield_subject, __delfield_subject, None) 2165 2166 def __getfield_dunno2(self): 2167 return self.__field_dunno2.getvalue() 2168 2169 def __setfield_dunno2(self, value): 2170 if isinstance(value,UNKNOWN): 2171 self.__field_dunno2=value 2172 else: 2173 self.__field_dunno2=UNKNOWN(value,**{'sizeinbytes': 47}) 2174 2175 def __delfield_dunno2(self): del self.__field_dunno2 2176 2177 dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None) 2178 2179 def __getfield_num_msg_elements(self): 2180 return self.__field_num_msg_elements.getvalue() 2181 2182 def __setfield_num_msg_elements(self, value): 2183 if isinstance(value,UINT): 2184 self.__field_num_msg_elements=value 2185 else: 2186 self.__field_num_msg_elements=UINT(value,**{'sizeinbytes': 1}) 2187 2188 def __delfield_num_msg_elements(self): del self.__field_num_msg_elements 2189 2190 num_msg_elements=property(__getfield_num_msg_elements, __setfield_num_msg_elements, __delfield_num_msg_elements, None) 2191 2192 def __getfield_msglengths(self): 2193 try: self.__field_msglengths 2194 except: 2195 self.__field_msglengths=LIST(**{'elementclass': _gen_p_lgvx8500_165, 'length': 10}) 2196 return self.__field_msglengths.getvalue() 2197 2198 def __setfield_msglengths(self, value): 2199 if isinstance(value,LIST): 2200 self.__field_msglengths=value 2201 else: 2202 self.__field_msglengths=LIST(value,**{'elementclass': _gen_p_lgvx8500_165, 'length': 10}) 2203 2204 def __delfield_msglengths(self): del self.__field_msglengths 2205 2206 msglengths=property(__getfield_msglengths, __setfield_msglengths, __delfield_msglengths, None) 2207 2208 def __getfield_unknown9(self): 2209 return self.__field_unknown9.getvalue() 2210 2211 def __setfield_unknown9(self, value): 2212 if isinstance(value,UNKNOWN): 2213 self.__field_unknown9=value 2214 else: 2215 self.__field_unknown9=UNKNOWN(value,**{'sizeinbytes': 10}) 2216 2217 def __delfield_unknown9(self): del self.__field_unknown9 2218 2219 unknown9=property(__getfield_unknown9, __setfield_unknown9, __delfield_unknown9, None) 2220 2221 def __getfield_msgs(self): 2222 try: self.__field_msgs 2223 except: 2224 self.__field_msgs=LIST(**{'length': 10, 'elementclass': SMSINBOXMSGFRAGMENT}) 2225 return self.__field_msgs.getvalue() 2226 2227 def __setfield_msgs(self, value): 2228 if isinstance(value,LIST): 2229 self.__field_msgs=value 2230 else: 2231 self.__field_msgs=LIST(value,**{'length': 10, 'elementclass': SMSINBOXMSGFRAGMENT}) 2232 2233 def __delfield_msgs(self): del self.__field_msgs 2234 2235 msgs=property(__getfield_msgs, __setfield_msgs, __delfield_msgs, None) 2236 2237 def __getfield_dunno3(self): 2238 return self.__field_dunno3.getvalue() 2239 2240 def __setfield_dunno3(self, value): 2241 if isinstance(value,UNKNOWN): 2242 self.__field_dunno3=value 2243 else: 2244 self.__field_dunno3=UNKNOWN(value,**{'sizeinbytes': 2594}) 2245 2246 def __delfield_dunno3(self): del self.__field_dunno3 2247 2248 dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None) 2249 2250 def __getfield_sender_length(self): 2251 return self.__field_sender_length.getvalue() 2252 2253 def __setfield_sender_length(self, value): 2254 if isinstance(value,UINT): 2255 self.__field_sender_length=value 2256 else: 2257 self.__field_sender_length=UINT(value,**{'sizeinbytes': 1}) 2258 2259 def __delfield_sender_length(self): del self.__field_sender_length 2260 2261 sender_length=property(__getfield_sender_length, __setfield_sender_length, __delfield_sender_length, None) 2262 2263 def __getfield_sender(self): 2264 try: self.__field_sender 2265 except: 2266 self.__field_sender=LIST(**{'elementclass': _gen_p_lgvx8500_171, 'length': 49}) 2267 return self.__field_sender.getvalue() 2268 2269 def __setfield_sender(self, value): 2270 if isinstance(value,LIST): 2271 self.__field_sender=value 2272 else: 2273 self.__field_sender=LIST(value,**{'elementclass': _gen_p_lgvx8500_171, 'length': 49}) 2274 2275 def __delfield_sender(self): del self.__field_sender 2276 2277 sender=property(__getfield_sender, __setfield_sender, __delfield_sender, None) 2278 2279 def __getfield_dunno4(self): 2280 return self.__field_dunno4.getvalue() 2281 2282 def __setfield_dunno4(self, value): 2283 if isinstance(value,UNKNOWN): 2284 self.__field_dunno4=value 2285 else: 2286 self.__field_dunno4=UNKNOWN(value,**{'sizeinbytes': 3}) 2287 2288 def __delfield_dunno4(self): del self.__field_dunno4 2289 2290 dunno4=property(__getfield_dunno4, __setfield_dunno4, __delfield_dunno4, None) 2291 2292 def __getfield_callback_length(self): 2293 return self.__field_callback_length.getvalue() 2294 2295 def __setfield_callback_length(self, value): 2296 if isinstance(value,UINT): 2297 self.__field_callback_length=value 2298 else: 2299 self.__field_callback_length=UINT(value,**{'sizeinbytes': 1}) 2300 2301 def __delfield_callback_length(self): del self.__field_callback_length 2302 2303 callback_length=property(__getfield_callback_length, __setfield_callback_length, __delfield_callback_length, None) 2304 2305 def __getfield_callback(self): 2306 return self.__field_callback.getvalue() 2307 2308 def __setfield_callback(self, value): 2309 if isinstance(value,USTRING): 2310 self.__field_callback=value 2311 else: 2312 self.__field_callback=USTRING(value,**{'sizeinbytes': 55}) 2313 2314 def __delfield_callback(self): del self.__field_callback 2315 2316 callback=property(__getfield_callback, __setfield_callback, __delfield_callback, None) 2317 2318 def __getfield_PAD(self): 2319 return self.__field_PAD.getvalue() 2320 2321 def __setfield_PAD(self, value): 2322 if isinstance(value,UNKNOWN): 2323 self.__field_PAD=value 2324 else: 2325 self.__field_PAD=UNKNOWN(value,) 2326 2327 def __delfield_PAD(self): del self.__field_PAD 2328 2329 PAD=property(__getfield_PAD, __setfield_PAD, __delfield_PAD, None) 2330 2331 def __getfield_bin_header1(self): 2332 try: self.__field_bin_header1 2333 except: 2334 self.__field_bin_header1=UINT(**{ 'default': 0 }) 2335 return self.__field_bin_header1.getvalue() 2336 2337 def __setfield_bin_header1(self, value): 2338 if isinstance(value,UINT): 2339 self.__field_bin_header1=value 2340 else: 2341 self.__field_bin_header1=UINT(value,**{ 'default': 0 }) 2342 2343 def __delfield_bin_header1(self): del self.__field_bin_header1 2344 2345 bin_header1=property(__getfield_bin_header1, __setfield_bin_header1, __delfield_bin_header1, None) 2346 2347 def __getfield_bin_header2(self): 2348 try: self.__field_bin_header2 2349 except: 2350 self.__field_bin_header2=UINT(**{ 'default': 0 }) 2351 return self.__field_bin_header2.getvalue() 2352 2353 def __setfield_bin_header2(self, value): 2354 if isinstance(value,UINT): 2355 self.__field_bin_header2=value 2356 else: 2357 self.__field_bin_header2=UINT(value,**{ 'default': 0 }) 2358 2359 def __delfield_bin_header2(self): del self.__field_bin_header2 2360 2361 bin_header2=property(__getfield_bin_header2, __setfield_bin_header2, __delfield_bin_header2, None) 2362 2363 def __getfield_multipartID(self): 2364 try: self.__field_multipartID 2365 except: 2366 self.__field_multipartID=UINT(**{ 'default': 0 }) 2367 return self.__field_multipartID.getvalue() 2368 2369 def __setfield_multipartID(self, value): 2370 if isinstance(value,UINT): 2371 self.__field_multipartID=value 2372 else: 2373 self.__field_multipartID=UINT(value,**{ 'default': 0 }) 2374 2375 def __delfield_multipartID(self): del self.__field_multipartID 2376 2377 multipartID=property(__getfield_multipartID, __setfield_multipartID, __delfield_multipartID, None) 2378 2379 def __getfield_bin_header3(self): 2380 try: self.__field_bin_header3 2381 except: 2382 self.__field_bin_header3=UINT(**{ 'default': 0 }) 2383 return self.__field_bin_header3.getvalue() 2384 2385 def __setfield_bin_header3(self, value): 2386 if isinstance(value,UINT): 2387 self.__field_bin_header3=value 2388 else: 2389 self.__field_bin_header3=UINT(value,**{ 'default': 0 }) 2390 2391 def __delfield_bin_header3(self): del self.__field_bin_header3 2392 2393 bin_header3=property(__getfield_bin_header3, __setfield_bin_header3, __delfield_bin_header3, None) 2394 2395 def iscontainer(self): 2396 return True 2397 2398 def containerelements(self): 2399 yield ('unknown1', self.__field_unknown1, None) 2400 yield ('lg_time', self.__field_lg_time, None) 2401 yield ('unknown2', self.__field_unknown2, None) 2402 yield ('GPStime', self.__field_GPStime, None) 2403 yield ('timesent', self.__field_timesent, None) 2404 yield ('read', self.__field_read, None) 2405 yield ('locked', self.__field_locked, None) 2406 yield ('priority', self.__field_priority, None) 2407 yield ('dunno1', self.__field_dunno1, None) 2408 yield ('subject', self.__field_subject, None) 2409 yield ('dunno2', self.__field_dunno2, None) 2410 yield ('num_msg_elements', self.__field_num_msg_elements, None) 2411 yield ('msglengths', self.__field_msglengths, None) 2412 yield ('unknown9', self.__field_unknown9, None) 2413 yield ('msgs', self.__field_msgs, None) 2414 yield ('dunno3', self.__field_dunno3, None) 2415 yield ('sender_length', self.__field_sender_length, None) 2416 yield ('sender', self.__field_sender, None) 2417 yield ('dunno4', self.__field_dunno4, None) 2418 yield ('callback_length', self.__field_callback_length, None) 2419 yield ('callback', self.__field_callback, None) 2420 yield ('PAD', self.__field_PAD, None) 2421 yield ('bin_header1', self.__field_bin_header1, None) 2422 yield ('bin_header2', self.__field_bin_header2, None) 2423 yield ('multipartID', self.__field_multipartID, None) 2424 yield ('bin_header3', self.__field_bin_header3, None) 2425 2426 2427 2428 2429 class _gen_p_lgvx8500_165(BaseProtogenClass): 2430 'Anonymous inner class' 2431 __fields=['msglength'] 2432 2433 def __init__(self, *args, **kwargs): 2434 dict={} 2435 # What was supplied to this function 2436 dict.update(kwargs) 2437 # Parent constructor 2438 super(_gen_p_lgvx8500_165,self).__init__(**dict) 2439 if self.__class__ is _gen_p_lgvx8500_165: 2440 self._update(args,dict) 2441 2442 2443 def getfields(self): 2444 return self.__fields 2445 2446 2447 def _update(self, args, kwargs): 2448 super(_gen_p_lgvx8500_165,self)._update(args,kwargs) 2449 keys=kwargs.keys() 2450 for key in keys: 2451 if key in self.__fields: 2452 setattr(self, key, kwargs[key]) 2453 del kwargs[key] 2454 # Were any unrecognized kwargs passed in? 2455 if __debug__: 2456 self._complainaboutunusedargs(_gen_p_lgvx8500_165,kwargs) 2457 if len(args): 2458 dict2={'sizeinbytes': 1} 2459 dict2.update(kwargs) 2460 kwargs=dict2 2461 self.__field_msglength=UINT(*args,**dict2) 2462 # Make all P fields that haven't already been constructed 2463 2464 2465 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 2466 'Writes this packet to the supplied buffer' 2467 self._bufferstartoffset=buf.getcurrentoffset() 2468 self.__field_msglength.writetobuffer(buf) 2469 self._bufferendoffset=buf.getcurrentoffset() 2470 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 2471 2472 2473 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 2474 'Reads this packet from the supplied buffer' 2475 self._bufferstartoffset=buf.getcurrentoffset() 2476 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 2477 self.__field_msglength=UINT(**{'sizeinbytes': 1}) 2478 self.__field_msglength.readfrombuffer(buf) 2479 self._bufferendoffset=buf.getcurrentoffset() 2480 2481 2482 def __getfield_msglength(self): 2483 return self.__field_msglength.getvalue() 2484 2485 def __setfield_msglength(self, value): 2486 if isinstance(value,UINT): 2487 self.__field_msglength=value 2488 else: 2489 self.__field_msglength=UINT(value,**{'sizeinbytes': 1}) 2490 2491 def __delfield_msglength(self): del self.__field_msglength 2492 2493 msglength=property(__getfield_msglength, __setfield_msglength, __delfield_msglength, "lengths of individual messages in septets") 2494 2495 def iscontainer(self): 2496 return True 2497 2498 def containerelements(self): 2499 yield ('msglength', self.__field_msglength, "lengths of individual messages in septets") 2500 2501 2502 2503 2504 class _gen_p_lgvx8500_171(BaseProtogenClass): 2505 'Anonymous inner class' 2506 __fields=['byte'] 2507 2508 def __init__(self, *args, **kwargs): 2509 dict={} 2510 # What was supplied to this function 2511 dict.update(kwargs) 2512 # Parent constructor 2513 super(_gen_p_lgvx8500_171,self).__init__(**dict) 2514 if self.__class__ is _gen_p_lgvx8500_171: 2515 self._update(args,dict) 2516 2517 2518 def getfields(self): 2519 return self.__fields 2520 2521 2522 def _update(self, args, kwargs): 2523 super(_gen_p_lgvx8500_171,self)._update(args,kwargs) 2524 keys=kwargs.keys() 2525 for key in keys: 2526 if key in self.__fields: 2527 setattr(self, key, kwargs[key]) 2528 del kwargs[key] 2529 # Were any unrecognized kwargs passed in? 2530 if __debug__: 2531 self._complainaboutunusedargs(_gen_p_lgvx8500_171,kwargs) 2532 if len(args): 2533 dict2={'sizeinbytes': 1} 2534 dict2.update(kwargs) 2535 kwargs=dict2 2536 self.__field_byte=UINT(*args,**dict2) 2537 # Make all P fields that haven't already been constructed 2538 2539 2540 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 2541 'Writes this packet to the supplied buffer' 2542 self._bufferstartoffset=buf.getcurrentoffset() 2543 self.__field_byte.writetobuffer(buf) 2544 self._bufferendoffset=buf.getcurrentoffset() 2545 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 2546 2547 2548 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 2549 'Reads this packet from the supplied buffer' 2550 self._bufferstartoffset=buf.getcurrentoffset() 2551 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 2552 self.__field_byte=UINT(**{'sizeinbytes': 1}) 2553 self.__field_byte.readfrombuffer(buf) 2554 self._bufferendoffset=buf.getcurrentoffset() 2555 2556 2557 def __getfield_byte(self): 2558 return self.__field_byte.getvalue() 2559 2560 def __setfield_byte(self, value): 2561 if isinstance(value,UINT): 2562 self.__field_byte=value 2563 else: 2564 self.__field_byte=UINT(value,**{'sizeinbytes': 1}) 2565 2566 def __delfield_byte(self): del self.__field_byte 2567 2568 byte=property(__getfield_byte, __setfield_byte, __delfield_byte, "individual byte of senders phone number") 2569 2570 def iscontainer(self): 2571 return True 2572 2573 def containerelements(self): 2574 yield ('byte', self.__field_byte, "individual byte of senders phone number") 2575 2576 2577 2578 2579 class sms_quick_text(BaseProtogenClass): 2580 __fields=['msgs'] 2581 2582 def __init__(self, *args, **kwargs): 2583 dict={} 2584 # What was supplied to this function 2585 dict.update(kwargs) 2586 # Parent constructor 2587 super(sms_quick_text,self).__init__(**dict) 2588 if self.__class__ is sms_quick_text: 2589 self._update(args,dict) 2590 2591 2592 def getfields(self): 2593 return self.__fields 2594 2595 2596 def _update(self, args, kwargs): 2597 super(sms_quick_text,self)._update(args,kwargs) 2598 keys=kwargs.keys() 2599 for key in keys: 2600 if key in self.__fields: 2601 setattr(self, key, kwargs[key]) 2602 del kwargs[key] 2603 # Were any unrecognized kwargs passed in? 2604 if __debug__: 2605 self._complainaboutunusedargs(sms_quick_text,kwargs) 2606 if len(args): 2607 dict2={'elementclass': _gen_p_lgvx8500_185, 'length': SMS_CANNED_MAX_ITEMS, 'createdefault': True} 2608 dict2.update(kwargs) 2609 kwargs=dict2 2610 self.__field_msgs=LIST(*args,**dict2) 2611 # Make all P fields that haven't already been constructed 2612 2613 2614 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 2615 'Writes this packet to the supplied buffer' 2616 self._bufferstartoffset=buf.getcurrentoffset() 2617 try: self.__field_msgs 2618 except: 2619 self.__field_msgs=LIST(**{'elementclass': _gen_p_lgvx8500_185, 'length': SMS_CANNED_MAX_ITEMS, 'createdefault': True}) 2620 self.__field_msgs.writetobuffer(buf) 2621 self._bufferendoffset=buf.getcurrentoffset() 2622 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 2623 2624 2625 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 2626 'Reads this packet from the supplied buffer' 2627 self._bufferstartoffset=buf.getcurrentoffset() 2628 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 2629 self.__field_msgs=LIST(**{'elementclass': _gen_p_lgvx8500_185, 'length': SMS_CANNED_MAX_ITEMS, 'createdefault': True}) 2630 self.__field_msgs.readfrombuffer(buf) 2631 self._bufferendoffset=buf.getcurrentoffset() 2632 2633 2634 def __getfield_msgs(self): 2635 try: self.__field_msgs 2636 except: 2637 self.__field_msgs=LIST(**{'elementclass': _gen_p_lgvx8500_185, 'length': SMS_CANNED_MAX_ITEMS, 'createdefault': True}) 2638 return self.__field_msgs.getvalue() 2639 2640 def __setfield_msgs(self, value): 2641 if isinstance(value,LIST): 2642 self.__field_msgs=value 2643 else: 2644 self.__field_msgs=LIST(value,**{'elementclass': _gen_p_lgvx8500_185, 'length': SMS_CANNED_MAX_ITEMS, 'createdefault': True}) 2645 2646 def __delfield_msgs(self): del self.__field_msgs 2647 2648 msgs=property(__getfield_msgs, __setfield_msgs, __delfield_msgs, None) 2649 2650 def iscontainer(self): 2651 return True 2652 2653 def containerelements(self): 2654 yield ('msgs', self.__field_msgs, None) 2655 2656 2657 2658 2659 class _gen_p_lgvx8500_185(BaseProtogenClass): 2660 'Anonymous inner class' 2661 __fields=['msg'] 2662 2663 def __init__(self, *args, **kwargs): 2664 dict={} 2665 # What was supplied to this function 2666 dict.update(kwargs) 2667 # Parent constructor 2668 super(_gen_p_lgvx8500_185,self).__init__(**dict) 2669 if self.__class__ is _gen_p_lgvx8500_185: 2670 self._update(args,dict) 2671 2672 2673 def getfields(self): 2674 return self.__fields 2675 2676 2677 def _update(self, args, kwargs): 2678 super(_gen_p_lgvx8500_185,self)._update(args,kwargs) 2679 keys=kwargs.keys() 2680 for key in keys: 2681 if key in self.__fields: 2682 setattr(self, key, kwargs[key]) 2683 del kwargs[key] 2684 # Were any unrecognized kwargs passed in? 2685 if __debug__: 2686 self._complainaboutunusedargs(_gen_p_lgvx8500_185,kwargs) 2687 if len(args): 2688 dict2={'sizeinbytes': 101, 'encoding': PHONE_ENCODING, 'default': ""} 2689 dict2.update(kwargs) 2690 kwargs=dict2 2691 self.__field_msg=USTRING(*args,**dict2) 2692 # Make all P fields that haven't already been constructed 2693 2694 2695 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 2696 'Writes this packet to the supplied buffer' 2697 self._bufferstartoffset=buf.getcurrentoffset() 2698 try: self.__field_msg 2699 except: 2700 self.__field_msg=USTRING(**{'sizeinbytes': 101, 'encoding': PHONE_ENCODING, 'default': ""}) 2701 self.__field_msg.writetobuffer(buf) 2702 self._bufferendoffset=buf.getcurrentoffset() 2703 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 2704 2705 2706 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 2707 'Reads this packet from the supplied buffer' 2708 self._bufferstartoffset=buf.getcurrentoffset() 2709 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 2710 self.__field_msg=USTRING(**{'sizeinbytes': 101, 'encoding': PHONE_ENCODING, 'default': ""}) 2711 self.__field_msg.readfrombuffer(buf) 2712 self._bufferendoffset=buf.getcurrentoffset() 2713 2714 2715 def __getfield_msg(self): 2716 try: self.__field_msg 2717 except: 2718 self.__field_msg=USTRING(**{'sizeinbytes': 101, 'encoding': PHONE_ENCODING, 'default': ""}) 2719 return self.__field_msg.getvalue() 2720 2721 def __setfield_msg(self, value): 2722 if isinstance(value,USTRING): 2723 self.__field_msg=value 2724 else: 2725 self.__field_msg=USTRING(value,**{'sizeinbytes': 101, 'encoding': PHONE_ENCODING, 'default': ""}) 2726 2727 def __delfield_msg(self): del self.__field_msg 2728 2729 msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None) 2730 2731 def iscontainer(self): 2732 return True 2733 2734 def containerelements(self): 2735 yield ('msg', self.__field_msg, None) 2736 2737 2738 2739 2740 class LockKeyReq(BaseProtogenClass): 2741 __fields=['cmd', 'lock'] 2742 2743 def __init__(self, *args, **kwargs): 2744 dict={} 2745 # What was supplied to this function 2746 dict.update(kwargs) 2747 # Parent constructor 2748 super(LockKeyReq,self).__init__(**dict) 2749 if self.__class__ is LockKeyReq: 2750 self._update(args,dict) 2751 2752 2753 def getfields(self): 2754 return self.__fields 2755 2756 2757 def _update(self, args, kwargs): 2758 super(LockKeyReq,self)._update(args,kwargs) 2759 keys=kwargs.keys() 2760 for key in keys: 2761 if key in self.__fields: 2762 setattr(self, key, kwargs[key]) 2763 del kwargs[key] 2764 # Were any unrecognized kwargs passed in? 2765 if __debug__: 2766 self._complainaboutunusedargs(LockKeyReq,kwargs) 2767 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 2768 # Make all P fields that haven't already been constructed 2769 2770 2771 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 2772 'Writes this packet to the supplied buffer' 2773 self._bufferstartoffset=buf.getcurrentoffset() 2774 try: self.__field_cmd 2775 except: 2776 self.__field_cmd=UINT(**{'sizeinbytes': 1, 'default': 0x21 }) 2777 self.__field_cmd.writetobuffer(buf) 2778 try: self.__field_lock 2779 except: 2780 self.__field_lock=UINT(**{'sizeinbytes': 2, 'default': 0 }) 2781 self.__field_lock.writetobuffer(buf) 2782 self._bufferendoffset=buf.getcurrentoffset() 2783 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 2784 2785 2786 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 2787 'Reads this packet from the supplied buffer' 2788 self._bufferstartoffset=buf.getcurrentoffset() 2789 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 2790 self.__field_cmd=UINT(**{'sizeinbytes': 1, 'default': 0x21 }) 2791 self.__field_cmd.readfrombuffer(buf) 2792 self.__field_lock=UINT(**{'sizeinbytes': 2, 'default': 0 }) 2793 self.__field_lock.readfrombuffer(buf) 2794 self._bufferendoffset=buf.getcurrentoffset() 2795 2796 2797 def __getfield_cmd(self): 2798 try: self.__field_cmd 2799 except: 2800 self.__field_cmd=UINT(**{'sizeinbytes': 1, 'default': 0x21 }) 2801 return self.__field_cmd.getvalue() 2802 2803 def __setfield_cmd(self, value): 2804 if isinstance(value,UINT): 2805 self.__field_cmd=value 2806 else: 2807 self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'default': 0x21 }) 2808 2809 def __delfield_cmd(self): del self.__field_cmd 2810 2811 cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None) 2812 2813 def __getfield_lock(self): 2814 try: self.__field_lock 2815 except: 2816 self.__field_lock=UINT(**{'sizeinbytes': 2, 'default': 0 }) 2817 return self.__field_lock.getvalue() 2818 2819 def __setfield_lock(self, value): 2820 if isinstance(value,UINT): 2821 self.__field_lock=value 2822 else: 2823 self.__field_lock=UINT(value,**{'sizeinbytes': 2, 'default': 0 }) 2824 2825 def __delfield_lock(self): del self.__field_lock 2826 2827 lock=property(__getfield_lock, __setfield_lock, __delfield_lock, "0=Lock, 1=Unlock") 2828 2829 def iscontainer(self): 2830 return True 2831 2832 def containerelements(self): 2833 yield ('cmd', self.__field_cmd, None) 2834 yield ('lock', self.__field_lock, "0=Lock, 1=Unlock") 2835 2836 2837 2838 2839 class KeyPressReq(BaseProtogenClass): 2840 __fields=['cmd', 'hold', 'key'] 2841 2842 def __init__(self, *args, **kwargs): 2843 dict={} 2844 # What was supplied to this function 2845 dict.update(kwargs) 2846 # Parent constructor 2847 super(KeyPressReq,self).__init__(**dict) 2848 if self.__class__ is KeyPressReq: 2849 self._update(args,dict) 2850 2851 2852 def getfields(self): 2853 return self.__fields 2854 2855 2856 def _update(self, args, kwargs): 2857 super(KeyPressReq,self)._update(args,kwargs) 2858 keys=kwargs.keys() 2859 for key in keys: 2860 if key in self.__fields: 2861 setattr(self, key, kwargs[key]) 2862 del kwargs[key] 2863 # Were any unrecognized kwargs passed in? 2864 if __debug__: 2865 self._complainaboutunusedargs(KeyPressReq,kwargs) 2866 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 2867 # Make all P fields that haven't already been constructed 2868 2869 2870 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 2871 'Writes this packet to the supplied buffer' 2872 self._bufferstartoffset=buf.getcurrentoffset() 2873 try: self.__field_cmd 2874 except: 2875 self.__field_cmd=UINT(**{'sizeinbytes': 1, 'default': 0x20 }) 2876 self.__field_cmd.writetobuffer(buf) 2877 try: self.__field_hold 2878 except: 2879 self.__field_hold=UINT(**{'sizeinbytes': 1, 'default': 0 }) 2880 self.__field_hold.writetobuffer(buf) 2881 self.__field_key.writetobuffer(buf) 2882 self._bufferendoffset=buf.getcurrentoffset() 2883 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 2884 2885 2886 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 2887 'Reads this packet from the supplied buffer' 2888 self._bufferstartoffset=buf.getcurrentoffset() 2889 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 2890 self.__field_cmd=UINT(**{'sizeinbytes': 1, 'default': 0x20 }) 2891 self.__field_cmd.readfrombuffer(buf) 2892 self.__field_hold=UINT(**{'sizeinbytes': 1, 'default': 0 }) 2893 self.__field_hold.readfrombuffer(buf) 2894 self.__field_key=STRING(**{'sizeinbytes': 1, 'terminator': None, 'sizeinbytes': 1 }) 2895 self.__field_key.readfrombuffer(buf) 2896 self._bufferendoffset=buf.getcurrentoffset() 2897 2898 2899 def __getfield_cmd(self): 2900 try: self.__field_cmd 2901 except: 2902 self.__field_cmd=UINT(**{'sizeinbytes': 1, 'default': 0x20 }) 2903 return self.__field_cmd.getvalue() 2904 2905 def __setfield_cmd(self, value): 2906 if isinstance(value,UINT): 2907 self.__field_cmd=value 2908 else: 2909 self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'default': 0x20 }) 2910 2911 def __delfield_cmd(self): del self.__field_cmd 2912 2913 cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None) 2914 2915 def __getfield_hold(self): 2916 try: self.__field_hold 2917 except: 2918 self.__field_hold=UINT(**{'sizeinbytes': 1, 'default': 0 }) 2919 return self.__field_hold.getvalue() 2920 2921 def __setfield_hold(self, value): 2922 if isinstance(value,UINT): 2923 self.__field_hold=value 2924 else: 2925 self.__field_hold=UINT(value,**{'sizeinbytes': 1, 'default': 0 }) 2926 2927 def __delfield_hold(self): del self.__field_hold 2928 2929 hold=property(__getfield_hold, __setfield_hold, __delfield_hold, None) 2930 2931 def __getfield_key(self): 2932 return self.__field_key.getvalue() 2933 2934 def __setfield_key(self, value): 2935 if isinstance(value,STRING): 2936 self.__field_key=value 2937 else: 2938 self.__field_key=STRING(value,**{'sizeinbytes': 1, 'terminator': None, 'sizeinbytes': 1 }) 2939 2940 def __delfield_key(self): del self.__field_key 2941 2942 key=property(__getfield_key, __setfield_key, __delfield_key, None) 2943 2944 def iscontainer(self): 2945 return True 2946 2947 def containerelements(self): 2948 yield ('cmd', self.__field_cmd, None) 2949 yield ('hold', self.__field_hold, None) 2950 yield ('key', self.__field_key, None) 2951 2952 2953 2954 2955 class t9udbfile(BaseProtogenClass): 2956 __fields=['file_length', 'unknown1', 'word_count', 'unknown2', 'free_space', 'unknown3', 'extra_cnt', 'unknown4', 'extras', 'A0', 'blocks'] 2957 2958 def __init__(self, *args, **kwargs): 2959 dict={} 2960 # What was supplied to this function 2961 dict.update(kwargs) 2962 # Parent constructor 2963 super(t9udbfile,self).__init__(**dict) 2964 if self.__class__ is t9udbfile: 2965 self._update(args,dict) 2966 2967 2968 def getfields(self): 2969 return self.__fields 2970 2971 2972 def _update(self, args, kwargs): 2973 super(t9udbfile,self)._update(args,kwargs) 2974 keys=kwargs.keys() 2975 for key in keys: 2976 if key in self.__fields: 2977 setattr(self, key, kwargs[key]) 2978 del kwargs[key] 2979 # Were any unrecognized kwargs passed in? 2980 if __debug__: 2981 self._complainaboutunusedargs(t9udbfile,kwargs) 2982 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 2983 # Make all P fields that haven't already been constructed 2984 2985 2986 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 2987 'Writes this packet to the supplied buffer' 2988 self._bufferstartoffset=buf.getcurrentoffset() 2989 try: self.__field_file_length 2990 except: 2991 self.__field_file_length=UINT(**{'sizeinbytes': 2, 'default': 0x5000 }) 2992 self.__field_file_length.writetobuffer(buf) 2993 try: self.__field_unknown1 2994 except: 2995 self.__field_unknown1=DATA(**{'sizeinbytes': 6, 'default': '\x7B\x1B\x00\x00\x01\x00' }) 2996 self.__field_unknown1.writetobuffer(buf) 2997 self.__field_word_count.writetobuffer(buf) 2998 try: self.__field_unknown2 2999 except: 3000 self.__field_unknown2=UINT(**{'sizeinbytes': 2, 'default': 0x00 }) 3001 self.__field_unknown2.writetobuffer(buf) 3002 self.__field_free_space.writetobuffer(buf) 3003 try: self.__field_unknown3 3004 except: 3005 self.__field_unknown3=DATA(**{'sizeinbytes': 10, 'default': Default_Header }) 3006 self.__field_unknown3.writetobuffer(buf) 3007 try: self.__field_extra_cnt 3008 except: 3009 self.__field_extra_cnt=UINT(**{'sizeinbytes': 2, 'default': 0 }) 3010 self.__field_extra_cnt.writetobuffer(buf) 3011 try: self.__field_unknown4 3012 except: 3013 self.__field_unknown4=DATA(**{'sizeinbytes': 18, 'default': Default_Header2 }) 3014 self.__field_unknown4.writetobuffer(buf) 3015 if self.extra_cnt: 3016 try: self.__field_extras 3017 except: 3018 self.__field_extras=LIST(**{'elementclass': _gen_p_lgvx8500_211, 'length': self.extra_cnt }) 3019 self.__field_extras.writetobuffer(buf) 3020 try: self.__field_A0 3021 except: 3022 self.__field_A0=UINT(**{'sizeinbytes': 1, 'constant': 0xA0 }) 3023 self.__field_A0.writetobuffer(buf) 3024 try: self.__field_blocks 3025 except: 3026 self.__field_blocks=LIST(**{'elementclass': _gen_p_lgvx8500_214, 'createdefault': True }) 3027 self.__field_blocks.writetobuffer(buf) 3028 self._bufferendoffset=buf.getcurrentoffset() 3029 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 3030 3031 3032 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 3033 'Reads this packet from the supplied buffer' 3034 self._bufferstartoffset=buf.getcurrentoffset() 3035 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 3036 self.__field_file_length=UINT(**{'sizeinbytes': 2, 'default': 0x5000 }) 3037 self.__field_file_length.readfrombuffer(buf) 3038 self.__field_unknown1=DATA(**{'sizeinbytes': 6, 'default': '\x7B\x1B\x00\x00\x01\x00' }) 3039 self.__field_unknown1.readfrombuffer(buf) 3040 self.__field_word_count=UINT(**{'sizeinbytes': 2}) 3041 self.__field_word_count.readfrombuffer(buf) 3042 self.__field_unknown2=UINT(**{'sizeinbytes': 2, 'default': 0x00 }) 3043 self.__field_unknown2.readfrombuffer(buf) 3044 self.__field_free_space=UINT(**{'sizeinbytes': 2}) 3045 self.__field_free_space.readfrombuffer(buf) 3046 self.__field_unknown3=DATA(**{'sizeinbytes': 10, 'default': Default_Header }) 3047 self.__field_unknown3.readfrombuffer(buf) 3048 self.__field_extra_cnt=UINT(**{'sizeinbytes': 2, 'default': 0 }) 3049 self.__field_extra_cnt.readfrombuffer(buf) 3050 self.__field_unknown4=DATA(**{'sizeinbytes': 18, 'default': Default_Header2 }) 3051 self.__field_unknown4.readfrombuffer(buf) 3052 if self.extra_cnt: 3053 self.__field_extras=LIST(**{'elementclass': _gen_p_lgvx8500_211, 'length': self.extra_cnt }) 3054 self.__field_extras.readfrombuffer(buf) 3055 self.__field_A0=UINT(**{'sizeinbytes': 1, 'constant': 0xA0 }) 3056 self.__field_A0.readfrombuffer(buf) 3057 self.__field_blocks=LIST(**{'elementclass': _gen_p_lgvx8500_214, 'createdefault': True }) 3058 self.__field_blocks.readfrombuffer(buf) 3059 self._bufferendoffset=buf.getcurrentoffset() 3060 3061 3062 def __getfield_file_length(self): 3063 try: self.__field_file_length 3064 except: 3065 self.__field_file_length=UINT(**{'sizeinbytes': 2, 'default': 0x5000 }) 3066 return self.__field_file_length.getvalue() 3067 3068 def __setfield_file_length(self, value): 3069 if isinstance(value,UINT): 3070 self.__field_file_length=value 3071 else: 3072 self.__field_file_length=UINT(value,**{'sizeinbytes': 2, 'default': 0x5000 }) 3073 3074 def __delfield_file_length(self): del self.__field_file_length 3075 3076 file_length=property(__getfield_file_length, __setfield_file_length, __delfield_file_length, None) 3077 3078 def __getfield_unknown1(self): 3079 try: self.__field_unknown1 3080 except: 3081 self.__field_unknown1=DATA(**{'sizeinbytes': 6, 'default': '\x7B\x1B\x00\x00\x01\x00' }) 3082 return self.__field_unknown1.getvalue() 3083 3084 def __setfield_unknown1(self, value): 3085 if isinstance(value,DATA): 3086 self.__field_unknown1=value 3087 else: 3088 self.__field_unknown1=DATA(value,**{'sizeinbytes': 6, 'default': '\x7B\x1B\x00\x00\x01\x00' }) 3089 3090 def __delfield_unknown1(self): del self.__field_unknown1 3091 3092 unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 3093 3094 def __getfield_word_count(self): 3095 return self.__field_word_count.getvalue() 3096 3097 def __setfield_word_count(self, value): 3098 if isinstance(value,UINT): 3099 self.__field_word_count=value 3100 else: 3101 self.__field_word_count=UINT(value,**{'sizeinbytes': 2}) 3102 3103 def __delfield_word_count(self): del self.__field_word_count 3104 3105 word_count=property(__getfield_word_count, __setfield_word_count, __delfield_word_count, None) 3106 3107 def __getfield_unknown2(self): 3108 try: self.__field_unknown2 3109 except: 3110 self.__field_unknown2=UINT(**{'sizeinbytes': 2, 'default': 0x00 }) 3111 return self.__field_unknown2.getvalue() 3112 3113 def __setfield_unknown2(self, value): 3114 if isinstance(value,UINT): 3115 self.__field_unknown2=value 3116 else: 3117 self.__field_unknown2=UINT(value,**{'sizeinbytes': 2, 'default': 0x00 }) 3118 3119 def __delfield_unknown2(self): del self.__field_unknown2 3120 3121 unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None) 3122 3123 def __getfield_free_space(self): 3124 return self.__field_free_space.getvalue() 3125 3126 def __setfield_free_space(self, value): 3127 if isinstance(value,UINT): 3128 self.__field_free_space=value 3129 else: 3130 self.__field_free_space=UINT(value,**{'sizeinbytes': 2}) 3131 3132 def __delfield_free_space(self): del self.__field_free_space 3133 3134 free_space=property(__getfield_free_space, __setfield_free_space, __delfield_free_space, None) 3135 3136 def __getfield_unknown3(self): 3137 try: self.__field_unknown3 3138 except: 3139 self.__field_unknown3=DATA(**{'sizeinbytes': 10, 'default': Default_Header }) 3140 return self.__field_unknown3.getvalue() 3141 3142 def __setfield_unknown3(self, value): 3143 if isinstance(value,DATA): 3144 self.__field_unknown3=value 3145 else: 3146 self.__field_unknown3=DATA(value,**{'sizeinbytes': 10, 'default': Default_Header }) 3147 3148 def __delfield_unknown3(self): del self.__field_unknown3 3149 3150 unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None) 3151 3152 def __getfield_extra_cnt(self): 3153 try: self.__field_extra_cnt 3154 except: 3155 self.__field_extra_cnt=UINT(**{'sizeinbytes': 2, 'default': 0 }) 3156 return self.__field_extra_cnt.getvalue() 3157 3158 def __setfield_extra_cnt(self, value): 3159 if isinstance(value,UINT): 3160 self.__field_extra_cnt=value 3161 else: 3162 self.__field_extra_cnt=UINT(value,**{'sizeinbytes': 2, 'default': 0 }) 3163 3164 def __delfield_extra_cnt(self): del self.__field_extra_cnt 3165 3166 extra_cnt=property(__getfield_extra_cnt, __setfield_extra_cnt, __delfield_extra_cnt, None) 3167 3168 def __getfield_unknown4(self): 3169 try: self.__field_unknown4 3170 except: 3171 self.__field_unknown4=DATA(**{'sizeinbytes': 18, 'default': Default_Header2 }) 3172 return self.__field_unknown4.getvalue() 3173 3174 def __setfield_unknown4(self, value): 3175 if isinstance(value,DATA): 3176 self.__field_unknown4=value 3177 else: 3178 self.__field_unknown4=DATA(value,**{'sizeinbytes': 18, 'default': Default_Header2 }) 3179 3180 def __delfield_unknown4(self): del self.__field_unknown4 3181 3182 unknown4=property(__getfield_unknown4, __setfield_unknown4, __delfield_unknown4, None) 3183 3184 def __getfield_extras(self): 3185 try: self.__field_extras 3186 except: 3187 self.__field_extras=LIST(**{'elementclass': _gen_p_lgvx8500_211, 'length': self.extra_cnt }) 3188 return self.__field_extras.getvalue() 3189 3190 def __setfield_extras(self, value): 3191 if isinstance(value,LIST): 3192 self.__field_extras=value 3193 else: 3194 self.__field_extras=LIST(value,**{'elementclass': _gen_p_lgvx8500_211, 'length': self.extra_cnt }) 3195 3196 def __delfield_extras(self): del self.__field_extras 3197 3198 extras=property(__getfield_extras, __setfield_extras, __delfield_extras, None) 3199 3200 def __getfield_A0(self): 3201 try: self.__field_A0 3202 except: 3203 self.__field_A0=UINT(**{'sizeinbytes': 1, 'constant': 0xA0 }) 3204 return self.__field_A0.getvalue() 3205 3206 def __setfield_A0(self, value): 3207 if isinstance(value,UINT): 3208 self.__field_A0=value 3209 else: 3210 self.__field_A0=UINT(value,**{'sizeinbytes': 1, 'constant': 0xA0 }) 3211 3212 def __delfield_A0(self): del self.__field_A0 3213 3214 A0=property(__getfield_A0, __setfield_A0, __delfield_A0, None) 3215 3216 def __getfield_blocks(self): 3217 try: self.__field_blocks 3218 except: 3219 self.__field_blocks=LIST(**{'elementclass': _gen_p_lgvx8500_214, 'createdefault': True }) 3220 return self.__field_blocks.getvalue() 3221 3222 def __setfield_blocks(self, value): 3223 if isinstance(value,LIST): 3224 self.__field_blocks=value 3225 else: 3226 self.__field_blocks=LIST(value,**{'elementclass': _gen_p_lgvx8500_214, 'createdefault': True }) 3227 3228 def __delfield_blocks(self): del self.__field_blocks 3229 3230 blocks=property(__getfield_blocks, __setfield_blocks, __delfield_blocks, None) 3231 3232 def iscontainer(self): 3233 return True 3234 3235 def containerelements(self): 3236 yield ('file_length', self.__field_file_length, None) 3237 yield ('unknown1', self.__field_unknown1, None) 3238 yield ('word_count', self.__field_word_count, None) 3239 yield ('unknown2', self.__field_unknown2, None) 3240 yield ('free_space', self.__field_free_space, None) 3241 yield ('unknown3', self.__field_unknown3, None) 3242 yield ('extra_cnt', self.__field_extra_cnt, None) 3243 yield ('unknown4', self.__field_unknown4, None) 3244 if self.extra_cnt: 3245 yield ('extras', self.__field_extras, None) 3246 yield ('A0', self.__field_A0, None) 3247 yield ('blocks', self.__field_blocks, None) 3248 3249 3250 3251 3252 class _gen_p_lgvx8500_211(BaseProtogenClass): 3253 'Anonymous inner class' 3254 __fields=['extra'] 3255 3256 def __init__(self, *args, **kwargs): 3257 dict={} 3258 # What was supplied to this function 3259 dict.update(kwargs) 3260 # Parent constructor 3261 super(_gen_p_lgvx8500_211,self).__init__(**dict) 3262 if self.__class__ is _gen_p_lgvx8500_211: 3263 self._update(args,dict) 3264 3265 3266 def getfields(self): 3267 return self.__fields 3268 3269 3270 def _update(self, args, kwargs): 3271 super(_gen_p_lgvx8500_211,self)._update(args,kwargs) 3272 keys=kwargs.keys() 3273 for key in keys: 3274 if key in self.__fields: 3275 setattr(self, key, kwargs[key]) 3276 del kwargs[key] 3277 # Were any unrecognized kwargs passed in? 3278 if __debug__: 3279 self._complainaboutunusedargs(_gen_p_lgvx8500_211,kwargs) 3280 if len(args): 3281 dict2={'sizeinbytes': 1, 'default': 0 } 3282 dict2.update(kwargs) 3283 kwargs=dict2 3284 self.__field_extra=UINT(*args,**dict2) 3285 # Make all P fields that haven't already been constructed 3286 3287 3288 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 3289 'Writes this packet to the supplied buffer' 3290 self._bufferstartoffset=buf.getcurrentoffset() 3291 try: self.__field_extra 3292 except: 3293 self.__field_extra=UINT(**{'sizeinbytes': 1, 'default': 0 }) 3294 self.__field_extra.writetobuffer(buf) 3295 self._bufferendoffset=buf.getcurrentoffset() 3296 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 3297 3298 3299 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 3300 'Reads this packet from the supplied buffer' 3301 self._bufferstartoffset=buf.getcurrentoffset() 3302 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 3303 self.__field_extra=UINT(**{'sizeinbytes': 1, 'default': 0 }) 3304 self.__field_extra.readfrombuffer(buf) 3305 self._bufferendoffset=buf.getcurrentoffset() 3306 3307 3308 def __getfield_extra(self): 3309 try: self.__field_extra 3310 except: 3311 self.__field_extra=UINT(**{'sizeinbytes': 1, 'default': 0 }) 3312 return self.__field_extra.getvalue() 3313 3314 def __setfield_extra(self, value): 3315 if isinstance(value,UINT): 3316 self.__field_extra=value 3317 else: 3318 self.__field_extra=UINT(value,**{'sizeinbytes': 1, 'default': 0 }) 3319 3320 def __delfield_extra(self): del self.__field_extra 3321 3322 extra=property(__getfield_extra, __setfield_extra, __delfield_extra, None) 3323 3324 def iscontainer(self): 3325 return True 3326 3327 def containerelements(self): 3328 yield ('extra', self.__field_extra, None) 3329 3330 3331 3332 3333 class _gen_p_lgvx8500_214(BaseProtogenClass): 3334 'Anonymous inner class' 3335 __fields=['block'] 3336 3337 def __init__(self, *args, **kwargs): 3338 dict={} 3339 # What was supplied to this function 3340 dict.update(kwargs) 3341 # Parent constructor 3342 super(_gen_p_lgvx8500_214,self).__init__(**dict) 3343 if self.__class__ is _gen_p_lgvx8500_214: 3344 self._update(args,dict) 3345 3346 3347 def getfields(self): 3348 return self.__fields 3349 3350 3351 def _update(self, args, kwargs): 3352 super(_gen_p_lgvx8500_214,self)._update(args,kwargs) 3353 keys=kwargs.keys() 3354 for key in keys: 3355 if key in self.__fields: 3356 setattr(self, key, kwargs[key]) 3357 del kwargs[key] 3358 # Were any unrecognized kwargs passed in? 3359 if __debug__: 3360 self._complainaboutunusedargs(_gen_p_lgvx8500_214,kwargs) 3361 if len(args): 3362 dict2={} 3363 dict2.update(kwargs) 3364 kwargs=dict2 3365 self.__field_block=T9USERDBBLOCK(*args,**dict2) 3366 # Make all P fields that haven't already been constructed 3367 3368 3369 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 3370 'Writes this packet to the supplied buffer' 3371 self._bufferstartoffset=buf.getcurrentoffset() 3372 self.__field_block.writetobuffer(buf) 3373 self._bufferendoffset=buf.getcurrentoffset() 3374 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 3375 3376 3377 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 3378 'Reads this packet from the supplied buffer' 3379 self._bufferstartoffset=buf.getcurrentoffset() 3380 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 3381 self.__field_block=T9USERDBBLOCK() 3382 self.__field_block.readfrombuffer(buf) 3383 self._bufferendoffset=buf.getcurrentoffset() 3384 3385 3386 def __getfield_block(self): 3387 return self.__field_block.getvalue() 3388 3389 def __setfield_block(self, value): 3390 if isinstance(value,T9USERDBBLOCK): 3391 self.__field_block=value 3392 else: 3393 self.__field_block=T9USERDBBLOCK(value,) 3394 3395 def __delfield_block(self): del self.__field_block 3396 3397 block=property(__getfield_block, __setfield_block, __delfield_block, None) 3398 3399 def iscontainer(self): 3400 return True 3401 3402 def containerelements(self): 3403 yield ('block', self.__field_block, None) 3404 3405 3406 3407 3408 class DMKeyReq(BaseProtogenClass): 3409 __fields=['cmd', 'body'] 3410 3411 def __init__(self, *args, **kwargs): 3412 dict={} 3413 # What was supplied to this function 3414 dict.update(kwargs) 3415 # Parent constructor 3416 super(DMKeyReq,self).__init__(**dict) 3417 if self.__class__ is DMKeyReq: 3418 self._update(args,dict) 3419 3420 3421 def getfields(self): 3422 return self.__fields 3423 3424 3425 def _update(self, args, kwargs): 3426 super(DMKeyReq,self)._update(args,kwargs) 3427 keys=kwargs.keys() 3428 for key in keys: 3429 if key in self.__fields: 3430 setattr(self, key, kwargs[key]) 3431 del kwargs[key] 3432 # Were any unrecognized kwargs passed in? 3433 if __debug__: 3434 self._complainaboutunusedargs(DMKeyReq,kwargs) 3435 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 3436 # Make all P fields that haven't already been constructed 3437 3438 3439 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 3440 'Writes this packet to the supplied buffer' 3441 self._bufferstartoffset=buf.getcurrentoffset() 3442 try: self.__field_cmd 3443 except: 3444 self.__field_cmd=UINT(**{'sizeinbytes': 1, 'default': 0xFE }) 3445 self.__field_cmd.writetobuffer(buf) 3446 try: self.__field_body 3447 except: 3448 self.__field_body=STRING(**{'sizeinbytes': 6, 'terminator': None, 'default': '\x00\x00\x00\x00\x00\x00' }) 3449 self.__field_body.writetobuffer(buf) 3450 self._bufferendoffset=buf.getcurrentoffset() 3451 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 3452 3453 3454 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 3455 'Reads this packet from the supplied buffer' 3456 self._bufferstartoffset=buf.getcurrentoffset() 3457 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 3458 self.__field_cmd=UINT(**{'sizeinbytes': 1, 'default': 0xFE }) 3459 self.__field_cmd.readfrombuffer(buf) 3460 self.__field_body=STRING(**{'sizeinbytes': 6, 'terminator': None, 'default': '\x00\x00\x00\x00\x00\x00' }) 3461 self.__field_body.readfrombuffer(buf) 3462 self._bufferendoffset=buf.getcurrentoffset() 3463 3464 3465 def __getfield_cmd(self): 3466 try: self.__field_cmd 3467 except: 3468 self.__field_cmd=UINT(**{'sizeinbytes': 1, 'default': 0xFE }) 3469 return self.__field_cmd.getvalue() 3470 3471 def __setfield_cmd(self, value): 3472 if isinstance(value,UINT): 3473 self.__field_cmd=value 3474 else: 3475 self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'default': 0xFE }) 3476 3477 def __delfield_cmd(self): del self.__field_cmd 3478 3479 cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None) 3480 3481 def __getfield_body(self): 3482 try: self.__field_body 3483 except: 3484 self.__field_body=STRING(**{'sizeinbytes': 6, 'terminator': None, 'default': '\x00\x00\x00\x00\x00\x00' }) 3485 return self.__field_body.getvalue() 3486 3487 def __setfield_body(self, value): 3488 if isinstance(value,STRING): 3489 self.__field_body=value 3490 else: 3491 self.__field_body=STRING(value,**{'sizeinbytes': 6, 'terminator': None, 'default': '\x00\x00\x00\x00\x00\x00' }) 3492 3493 def __delfield_body(self): del self.__field_body 3494 3495 body=property(__getfield_body, __setfield_body, __delfield_body, None) 3496 3497 def iscontainer(self): 3498 return True 3499 3500 def containerelements(self): 3501 yield ('cmd', self.__field_cmd, None) 3502 yield ('body', self.__field_body, None) 3503 3504 3505 3506 3507 class DMKeyResp(BaseProtogenClass): 3508 __fields=['cmd', 'code', 'key', 'one'] 3509 3510 def __init__(self, *args, **kwargs): 3511 dict={} 3512 # What was supplied to this function 3513 dict.update(kwargs) 3514 # Parent constructor 3515 super(DMKeyResp,self).__init__(**dict) 3516 if self.__class__ is DMKeyResp: 3517 self._update(args,dict) 3518 3519 3520 def getfields(self): 3521 return self.__fields 3522 3523 3524 def _update(self, args, kwargs): 3525 super(DMKeyResp,self)._update(args,kwargs) 3526 keys=kwargs.keys() 3527 for key in keys: 3528 if key in self.__fields: 3529 setattr(self, key, kwargs[key]) 3530 del kwargs[key] 3531 # Were any unrecognized kwargs passed in? 3532 if __debug__: 3533 self._complainaboutunusedargs(DMKeyResp,kwargs) 3534 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 3535 # Make all P fields that haven't already been constructed 3536 3537 3538 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 3539 'Writes this packet to the supplied buffer' 3540 self._bufferstartoffset=buf.getcurrentoffset() 3541 self.__field_cmd.writetobuffer(buf) 3542 self.__field_code.writetobuffer(buf) 3543 self.__field_key.writetobuffer(buf) 3544 self.__field_one.writetobuffer(buf) 3545 self._bufferendoffset=buf.getcurrentoffset() 3546 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 3547 3548 3549 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 3550 'Reads this packet from the supplied buffer' 3551 self._bufferstartoffset=buf.getcurrentoffset() 3552 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 3553 self.__field_cmd=UINT(**{'sizeinbytes': 1}) 3554 self.__field_cmd.readfrombuffer(buf) 3555 self.__field_code=UINT(**{'sizeinbytes': 1}) 3556 self.__field_code.readfrombuffer(buf) 3557 self.__field_key=UINT(**{'sizeinbytes': 4}) 3558 self.__field_key.readfrombuffer(buf) 3559 self.__field_one=UINT(**{'sizeinbytes': 1}) 3560 self.__field_one.readfrombuffer(buf) 3561 self._bufferendoffset=buf.getcurrentoffset() 3562 3563 3564 def __getfield_cmd(self): 3565 return self.__field_cmd.getvalue() 3566 3567 def __setfield_cmd(self, value): 3568 if isinstance(value,UINT): 3569 self.__field_cmd=value 3570 else: 3571 self.__field_cmd=UINT(value,**{'sizeinbytes': 1}) 3572 3573 def __delfield_cmd(self): del self.__field_cmd 3574 3575 cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None) 3576 3577 def __getfield_code(self): 3578 return self.__field_code.getvalue() 3579 3580 def __setfield_code(self, value): 3581 if isinstance(value,UINT): 3582 self.__field_code=value 3583 else: 3584 self.__field_code=UINT(value,**{'sizeinbytes': 1}) 3585 3586 def __delfield_code(self): del self.__field_code 3587 3588 code=property(__getfield_code, __setfield_code, __delfield_code, None) 3589 3590 def __getfield_key(self): 3591 return self.__field_key.getvalue() 3592 3593 def __setfield_key(self, value): 3594 if isinstance(value,UINT): 3595 self.__field_key=value 3596 else: 3597 self.__field_key=UINT(value,**{'sizeinbytes': 4}) 3598 3599 def __delfield_key(self): del self.__field_key 3600 3601 key=property(__getfield_key, __setfield_key, __delfield_key, None) 3602 3603 def __getfield_one(self): 3604 return self.__field_one.getvalue() 3605 3606 def __setfield_one(self, value): 3607 if isinstance(value,UINT): 3608 self.__field_one=value 3609 else: 3610 self.__field_one=UINT(value,**{'sizeinbytes': 1}) 3611 3612 def __delfield_one(self): del self.__field_one 3613 3614 one=property(__getfield_one, __setfield_one, __delfield_one, None) 3615 3616 def iscontainer(self): 3617 return True 3618 3619 def containerelements(self): 3620 yield ('cmd', self.__field_cmd, None) 3621 yield ('code', self.__field_code, None) 3622 yield ('key', self.__field_key, None) 3623 yield ('one', self.__field_one, None) 3624 3625 3626 3627 3628 class DMReq(BaseProtogenClass): 3629 __fields=['cmd', 'one', 'key', 'zero'] 3630 3631 def __init__(self, *args, **kwargs): 3632 dict={} 3633 # What was supplied to this function 3634 dict.update(kwargs) 3635 # Parent constructor 3636 super(DMReq,self).__init__(**dict) 3637 if self.__class__ is DMReq: 3638 self._update(args,dict) 3639 3640 3641 def getfields(self): 3642 return self.__fields 3643 3644 3645 def _update(self, args, kwargs): 3646 super(DMReq,self)._update(args,kwargs) 3647 keys=kwargs.keys() 3648 for key in keys: 3649 if key in self.__fields: 3650 setattr(self, key, kwargs[key]) 3651 del kwargs[key] 3652 # Were any unrecognized kwargs passed in? 3653 if __debug__: 3654 self._complainaboutunusedargs(DMReq,kwargs) 3655 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 3656 # Make all P fields that haven't already been constructed 3657 3658 3659 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 3660 'Writes this packet to the supplied buffer' 3661 self._bufferstartoffset=buf.getcurrentoffset() 3662 try: self.__field_cmd 3663 except: 3664 self.__field_cmd=UINT(**{'sizeinbytes': 1, 'default': 0xFE }) 3665 self.__field_cmd.writetobuffer(buf) 3666 try: self.__field_one 3667 except: 3668 self.__field_one=UINT(**{'sizeinbytes': 1, 'default': 1 }) 3669 self.__field_one.writetobuffer(buf) 3670 self.__field_key.writetobuffer(buf) 3671 try: self.__field_zero 3672 except: 3673 self.__field_zero=UINT(**{'sizeinbytes': 1, 'default': 0 }) 3674 self.__field_zero.writetobuffer(buf) 3675 self._bufferendoffset=buf.getcurrentoffset() 3676 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 3677 3678 3679 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 3680 'Reads this packet from the supplied buffer' 3681 self._bufferstartoffset=buf.getcurrentoffset() 3682 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 3683 self.__field_cmd=UINT(**{'sizeinbytes': 1, 'default': 0xFE }) 3684 self.__field_cmd.readfrombuffer(buf) 3685 self.__field_one=UINT(**{'sizeinbytes': 1, 'default': 1 }) 3686 self.__field_one.readfrombuffer(buf) 3687 self.__field_key=UINT(**{'sizeinbytes': 4}) 3688 self.__field_key.readfrombuffer(buf) 3689 self.__field_zero=UINT(**{'sizeinbytes': 1, 'default': 0 }) 3690 self.__field_zero.readfrombuffer(buf) 3691 self._bufferendoffset=buf.getcurrentoffset() 3692 3693 3694 def __getfield_cmd(self): 3695 try: self.__field_cmd 3696 except: 3697 self.__field_cmd=UINT(**{'sizeinbytes': 1, 'default': 0xFE }) 3698 return self.__field_cmd.getvalue() 3699 3700 def __setfield_cmd(self, value): 3701 if isinstance(value,UINT): 3702 self.__field_cmd=value 3703 else: 3704 self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'default': 0xFE }) 3705 3706 def __delfield_cmd(self): del self.__field_cmd 3707 3708 cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None) 3709 3710 def __getfield_one(self): 3711 try: self.__field_one 3712 except: 3713 self.__field_one=UINT(**{'sizeinbytes': 1, 'default': 1 }) 3714 return self.__field_one.getvalue() 3715 3716 def __setfield_one(self, value): 3717 if isinstance(value,UINT): 3718 self.__field_one=value 3719 else: 3720 self.__field_one=UINT(value,**{'sizeinbytes': 1, 'default': 1 }) 3721 3722 def __delfield_one(self): del self.__field_one 3723 3724 one=property(__getfield_one, __setfield_one, __delfield_one, None) 3725 3726 def __getfield_key(self): 3727 return self.__field_key.getvalue() 3728 3729 def __setfield_key(self, value): 3730 if isinstance(value,UINT): 3731 self.__field_key=value 3732 else: 3733 self.__field_key=UINT(value,**{'sizeinbytes': 4}) 3734 3735 def __delfield_key(self): del self.__field_key 3736 3737 key=property(__getfield_key, __setfield_key, __delfield_key, None) 3738 3739 def __getfield_zero(self): 3740 try: self.__field_zero 3741 except: 3742 self.__field_zero=UINT(**{'sizeinbytes': 1, 'default': 0 }) 3743 return self.__field_zero.getvalue() 3744 3745 def __setfield_zero(self, value): 3746 if isinstance(value,UINT): 3747 self.__field_zero=value 3748 else: 3749 self.__field_zero=UINT(value,**{'sizeinbytes': 1, 'default': 0 }) 3750 3751 def __delfield_zero(self): del self.__field_zero 3752 3753 zero=property(__getfield_zero, __setfield_zero, __delfield_zero, None) 3754 3755 def iscontainer(self): 3756 return True 3757 3758 def containerelements(self): 3759 yield ('cmd', self.__field_cmd, None) 3760 yield ('one', self.__field_one, None) 3761 yield ('key', self.__field_key, None) 3762 yield ('zero', self.__field_zero, None) 3763 3764 3765 3766 3767 class DMResp(BaseProtogenClass): 3768 __fields=['cmd', 'one', 'key', 'zero2one'] 3769 3770 def __init__(self, *args, **kwargs): 3771 dict={} 3772 # What was supplied to this function 3773 dict.update(kwargs) 3774 # Parent constructor 3775 super(DMResp,self).__init__(**dict) 3776 if self.__class__ is DMResp: 3777 self._update(args,dict) 3778 3779 3780 def getfields(self): 3781 return self.__fields 3782 3783 3784 def _update(self, args, kwargs): 3785 super(DMResp,self)._update(args,kwargs) 3786 keys=kwargs.keys() 3787 for key in keys: 3788 if key in self.__fields: 3789 setattr(self, key, kwargs[key]) 3790 del kwargs[key] 3791 # Were any unrecognized kwargs passed in? 3792 if __debug__: 3793 self._complainaboutunusedargs(DMResp,kwargs) 3794 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 3795 # Make all P fields that haven't already been constructed 3796 3797 3798 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 3799 'Writes this packet to the supplied buffer' 3800 self._bufferstartoffset=buf.getcurrentoffset() 3801 self.__field_cmd.writetobuffer(buf) 3802 self.__field_one.writetobuffer(buf) 3803 self.__field_key.writetobuffer(buf) 3804 self.__field_zero2one.writetobuffer(buf) 3805 self._bufferendoffset=buf.getcurrentoffset() 3806 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 3807 3808 3809 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 3810 'Reads this packet from the supplied buffer' 3811 self._bufferstartoffset=buf.getcurrentoffset() 3812 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 3813 self.__field_cmd=UINT(**{'sizeinbytes': 1}) 3814 self.__field_cmd.readfrombuffer(buf) 3815 self.__field_one=UINT(**{'sizeinbytes': 1}) 3816 self.__field_one.readfrombuffer(buf) 3817 self.__field_key=UINT(**{'sizeinbytes': 4}) 3818 self.__field_key.readfrombuffer(buf) 3819 self.__field_zero2one=UINT(**{'sizeinbytes': 1}) 3820 self.__field_zero2one.readfrombuffer(buf) 3821 self._bufferendoffset=buf.getcurrentoffset() 3822 3823 3824 def __getfield_cmd(self): 3825 return self.__field_cmd.getvalue() 3826 3827 def __setfield_cmd(self, value): 3828 if isinstance(value,UINT): 3829 self.__field_cmd=value 3830 else: 3831 self.__field_cmd=UINT(value,**{'sizeinbytes': 1}) 3832 3833 def __delfield_cmd(self): del self.__field_cmd 3834 3835 cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None) 3836 3837 def __getfield_one(self): 3838 return self.__field_one.getvalue() 3839 3840 def __setfield_one(self, value): 3841 if isinstance(value,UINT): 3842 self.__field_one=value 3843 else: 3844 self.__field_one=UINT(value,**{'sizeinbytes': 1}) 3845 3846 def __delfield_one(self): del self.__field_one 3847 3848 one=property(__getfield_one, __setfield_one, __delfield_one, None) 3849 3850 def __getfield_key(self): 3851 return self.__field_key.getvalue() 3852 3853 def __setfield_key(self, value): 3854 if isinstance(value,UINT): 3855 self.__field_key=value 3856 else: 3857 self.__field_key=UINT(value,**{'sizeinbytes': 4}) 3858 3859 def __delfield_key(self): del self.__field_key 3860 3861 key=property(__getfield_key, __setfield_key, __delfield_key, None) 3862 3863 def __getfield_zero2one(self): 3864 return self.__field_zero2one.getvalue() 3865 3866 def __setfield_zero2one(self, value): 3867 if isinstance(value,UINT): 3868 self.__field_zero2one=value 3869 else: 3870 self.__field_zero2one=UINT(value,**{'sizeinbytes': 1}) 3871 3872 def __delfield_zero2one(self): del self.__field_zero2one 3873 3874 zero2one=property(__getfield_zero2one, __setfield_zero2one, __delfield_zero2one, None) 3875 3876 def iscontainer(self): 3877 return True 3878 3879 def containerelements(self): 3880 yield ('cmd', self.__field_cmd, None) 3881 yield ('one', self.__field_one, None) 3882 yield ('key', self.__field_key, None) 3883 yield ('zero2one', self.__field_zero2one, None) 3884 3885 3886 3887 3888
Generated by PyXR 0.9.4