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