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