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