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