0001
0003 """Various descriptions of data specific to LG VX7000"""
0004
0005 from common import PhoneBookBusyException
0006
0007 from prototypes import *
0008
0009 from p_lg import *
0011
0012 from p_lgvx4400 import *
0015
0016 UINT=UINTlsb
0018 BOOL=BOOLlsb
0019
0020 NORINGTONE=65535
0021 NOMSGRINGTONE=65535
0022 NOWALLPAPER=0
0023
0024 NUMSPEEDDIALS=100
0025 FIRSTSPEEDDIAL=2
0026 LASTSPEEDDIAL=99
0027 NUMPHONEBOOKENTRIES=500
0028 MAXCALENDARDESCRIPTION=38
0029
0030 NUMEMAILS=2
0031 NUMPHONENUMBERS=5
0032
0033 PHONE_ENCODING='iso8859_1'
0034
0035 text_memo_file='sch/memo.dat'
0037
0038 sms_dir='sms'
0040 sms_ext='.dat'
0041 sms_inbox_prefix='sms/inbox'
0042 sms_inbox_name_len=len(sms_inbox_prefix)+3+len(sms_ext)
0043 sms_saved_prefix='sms/sf'
0044 sms_saved_name_len=len(sms_saved_prefix)+2+len(sms_ext)
0045 sms_outbox_prefix='sms/outbox'
0046 sms_outbox_name_len=len(sms_outbox_prefix)+3+len(sms_ext)
0047 sms_canned_file='sms/mediacan000.dat'
0048 SMS_CANNED_MAX_ITEMS=18
0049
0050 incoming_call_file='pim/incoming_log.dat'
0052 outgoing_call_file='pim/outgoing_log.dat'
0053 missed_call_file='pim/missed_log.dat'
0054
0055 numbertypetab= ( None, 'cell', 'home', 'office', 'cell2', 'fax' )
0057
0058 class speeddial(BaseProtogenClass):
0059 __fields=['entry', 'number']
0060
0061 def __init__(self, *args, **kwargs):
0062 dict={}
0063 dict.update(kwargs)
0065 super(speeddial,self).__init__(**dict)
0067 if self.__class__ is speeddial:
0068 self._update(args,dict)
0069
0070
0071 def getfields(self):
0072 return self.__fields
0073
0074
0075 def _update(self, args, kwargs):
0076 super(speeddial,self)._update(args,kwargs)
0077 keys=kwargs.keys()
0078 for key in keys:
0079 if key in self.__fields:
0080 setattr(self, key, kwargs[key])
0081 del kwargs[key]
0082 if __debug__:
0084 self._complainaboutunusedargs(speeddial,kwargs)
0085 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0086
0088
0089 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0090 'Writes this packet to the supplied buffer'
0091 self._bufferstartoffset=buf.getcurrentoffset()
0092 try: self.__field_entry
0093 except:
0094 self.__field_entry=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
0095 self.__field_entry.writetobuffer(buf)
0096 try: self.__field_number
0097 except:
0098 self.__field_number=UINT(**{'sizeinbytes': 1, 'default': 0xff})
0099 self.__field_number.writetobuffer(buf)
0100 self._bufferendoffset=buf.getcurrentoffset()
0101 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0102
0103
0104 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0105 'Reads this packet from the supplied buffer'
0106 self._bufferstartoffset=buf.getcurrentoffset()
0107 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0108 self.__field_entry=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
0109 self.__field_entry.readfrombuffer(buf)
0110 self.__field_number=UINT(**{'sizeinbytes': 1, 'default': 0xff})
0111 self.__field_number.readfrombuffer(buf)
0112 self._bufferendoffset=buf.getcurrentoffset()
0113
0114
0115 def __getfield_entry(self):
0116 try: self.__field_entry
0117 except:
0118 self.__field_entry=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
0119 return self.__field_entry.getvalue()
0120
0121 def __setfield_entry(self, value):
0122 if isinstance(value,UINT):
0123 self.__field_entry=value
0124 else:
0125 self.__field_entry=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff})
0126
0127 def __delfield_entry(self): del self.__field_entry
0128
0129 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
0130
0131 def __getfield_number(self):
0132 try: self.__field_number
0133 except:
0134 self.__field_number=UINT(**{'sizeinbytes': 1, 'default': 0xff})
0135 return self.__field_number.getvalue()
0136
0137 def __setfield_number(self, value):
0138 if isinstance(value,UINT):
0139 self.__field_number=value
0140 else:
0141 self.__field_number=UINT(value,**{'sizeinbytes': 1, 'default': 0xff})
0142
0143 def __delfield_number(self): del self.__field_number
0144
0145 number=property(__getfield_number, __setfield_number, __delfield_number, None)
0146
0147 def iscontainer(self):
0148 return True
0149
0150 def containerelements(self):
0151 yield ('entry', self.__field_entry, None)
0152 yield ('number', self.__field_number, None)
0153
0154
0155
0156
0157 class speeddials(BaseProtogenClass):
0158 __fields=['speeddials']
0159
0160 def __init__(self, *args, **kwargs):
0161 dict={}
0162 dict.update(kwargs)
0164 super(speeddials,self).__init__(**dict)
0166 if self.__class__ is speeddials:
0167 self._update(args,dict)
0168
0169
0170 def getfields(self):
0171 return self.__fields
0172
0173
0174 def _update(self, args, kwargs):
0175 super(speeddials,self)._update(args,kwargs)
0176 keys=kwargs.keys()
0177 for key in keys:
0178 if key in self.__fields:
0179 setattr(self, key, kwargs[key])
0180 del kwargs[key]
0181 if __debug__:
0183 self._complainaboutunusedargs(speeddials,kwargs)
0184 if len(args):
0185 dict2={'length': NUMSPEEDDIALS, 'elementclass': speeddial}
0186 dict2.update(kwargs)
0187 kwargs=dict2
0188 self.__field_speeddials=LIST(*args,**dict2)
0189
0191
0192 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0193 'Writes this packet to the supplied buffer'
0194 self._bufferstartoffset=buf.getcurrentoffset()
0195 try: self.__field_speeddials
0196 except:
0197 self.__field_speeddials=LIST(**{'length': NUMSPEEDDIALS, 'elementclass': speeddial})
0198 self.__field_speeddials.writetobuffer(buf)
0199 self._bufferendoffset=buf.getcurrentoffset()
0200 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0201
0202
0203 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0204 'Reads this packet from the supplied buffer'
0205 self._bufferstartoffset=buf.getcurrentoffset()
0206 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0207 self.__field_speeddials=LIST(**{'length': NUMSPEEDDIALS, 'elementclass': speeddial})
0208 self.__field_speeddials.readfrombuffer(buf)
0209 self._bufferendoffset=buf.getcurrentoffset()
0210
0211
0212 def __getfield_speeddials(self):
0213 try: self.__field_speeddials
0214 except:
0215 self.__field_speeddials=LIST(**{'length': NUMSPEEDDIALS, 'elementclass': speeddial})
0216 return self.__field_speeddials.getvalue()
0217
0218 def __setfield_speeddials(self, value):
0219 if isinstance(value,LIST):
0220 self.__field_speeddials=value
0221 else:
0222 self.__field_speeddials=LIST(value,**{'length': NUMSPEEDDIALS, 'elementclass': speeddial})
0223
0224 def __delfield_speeddials(self): del self.__field_speeddials
0225
0226 speeddials=property(__getfield_speeddials, __setfield_speeddials, __delfield_speeddials, None)
0227
0228 def iscontainer(self):
0229 return True
0230
0231 def containerelements(self):
0232 yield ('speeddials', self.__field_speeddials, None)
0233
0234
0235
0236
0237 class indexentry(BaseProtogenClass):
0238 __fields=['index', 'type', 'filename', 'date', 'dunno']
0239
0240 def __init__(self, *args, **kwargs):
0241 dict={}
0242 dict.update(kwargs)
0244 super(indexentry,self).__init__(**dict)
0246 if self.__class__ is indexentry:
0247 self._update(args,dict)
0248
0249
0250 def getfields(self):
0251 return self.__fields
0252
0253
0254 def _update(self, args, kwargs):
0255 super(indexentry,self)._update(args,kwargs)
0256 keys=kwargs.keys()
0257 for key in keys:
0258 if key in self.__fields:
0259 setattr(self, key, kwargs[key])
0260 del kwargs[key]
0261 if __debug__:
0263 self._complainaboutunusedargs(indexentry,kwargs)
0264 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0265
0267
0268 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0269 'Writes this packet to the supplied buffer'
0270 self._bufferstartoffset=buf.getcurrentoffset()
0271 self.__field_index.writetobuffer(buf)
0272 self.__field_type.writetobuffer(buf)
0273 self.__field_filename.writetobuffer(buf)
0274 try: self.__field_date
0275 except:
0276 self.__field_date=UINT(**{'sizeinbytes': 4, 'default': 0})
0277 self.__field_date.writetobuffer(buf)
0278 self.__field_dunno.writetobuffer(buf)
0279 self._bufferendoffset=buf.getcurrentoffset()
0280 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0281
0282
0283 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0284 'Reads this packet from the supplied buffer'
0285 self._bufferstartoffset=buf.getcurrentoffset()
0286 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0287 self.__field_index=UINT(**{'sizeinbytes': 2})
0288 self.__field_index.readfrombuffer(buf)
0289 self.__field_type=UINT(**{'sizeinbytes': 2})
0290 self.__field_type.readfrombuffer(buf)
0291 self.__field_filename=USTRING(**{'sizeinbytes': 84})
0292 self.__field_filename.readfrombuffer(buf)
0293 self.__field_date=UINT(**{'sizeinbytes': 4, 'default': 0})
0294 self.__field_date.readfrombuffer(buf)
0295 self.__field_dunno=UINT(**{'sizeinbytes': 4})
0296 self.__field_dunno.readfrombuffer(buf)
0297 self._bufferendoffset=buf.getcurrentoffset()
0298
0299
0300 def __getfield_index(self):
0301 return self.__field_index.getvalue()
0302
0303 def __setfield_index(self, value):
0304 if isinstance(value,UINT):
0305 self.__field_index=value
0306 else:
0307 self.__field_index=UINT(value,**{'sizeinbytes': 2})
0308
0309 def __delfield_index(self): del self.__field_index
0310
0311 index=property(__getfield_index, __setfield_index, __delfield_index, None)
0312
0313 def __getfield_type(self):
0314 return self.__field_type.getvalue()
0315
0316 def __setfield_type(self, value):
0317 if isinstance(value,UINT):
0318 self.__field_type=value
0319 else:
0320 self.__field_type=UINT(value,**{'sizeinbytes': 2})
0321
0322 def __delfield_type(self): del self.__field_type
0323
0324 type=property(__getfield_type, __setfield_type, __delfield_type, None)
0325
0326 def __getfield_filename(self):
0327 return self.__field_filename.getvalue()
0328
0329 def __setfield_filename(self, value):
0330 if isinstance(value,USTRING):
0331 self.__field_filename=value
0332 else:
0333 self.__field_filename=USTRING(value,**{'sizeinbytes': 84})
0334
0335 def __delfield_filename(self): del self.__field_filename
0336
0337 filename=property(__getfield_filename, __setfield_filename, __delfield_filename, "includes full pathname")
0338
0339 def __getfield_date(self):
0340 try: self.__field_date
0341 except:
0342 self.__field_date=UINT(**{'sizeinbytes': 4, 'default': 0})
0343 return self.__field_date.getvalue()
0344
0345 def __setfield_date(self, value):
0346 if isinstance(value,UINT):
0347 self.__field_date=value
0348 else:
0349 self.__field_date=UINT(value,**{'sizeinbytes': 4, 'default': 0})
0350
0351 def __delfield_date(self): del self.__field_date
0352
0353 date=property(__getfield_date, __setfield_date, __delfield_date, "i think this is bitfield of the date")
0354
0355 def __getfield_dunno(self):
0356 return self.__field_dunno.getvalue()
0357
0358 def __setfield_dunno(self, value):
0359 if isinstance(value,UINT):
0360 self.__field_dunno=value
0361 else:
0362 self.__field_dunno=UINT(value,**{'sizeinbytes': 4})
0363
0364 def __delfield_dunno(self): del self.__field_dunno
0365
0366 dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, None)
0367
0368 def iscontainer(self):
0369 return True
0370
0371 def containerelements(self):
0372 yield ('index', self.__field_index, None)
0373 yield ('type', self.__field_type, None)
0374 yield ('filename', self.__field_filename, "includes full pathname")
0375 yield ('date', self.__field_date, "i think this is bitfield of the date")
0376 yield ('dunno', self.__field_dunno, None)
0377
0378
0379
0380
0381 class indexfile(BaseProtogenClass):
0382 "Used for tracking wallpaper and ringtones"
0383 __fields=['items']
0384
0385 def __init__(self, *args, **kwargs):
0386 dict={}
0387 dict.update(kwargs)
0389 super(indexfile,self).__init__(**dict)
0391 if self.__class__ is indexfile:
0392 self._update(args,dict)
0393
0394
0395 def getfields(self):
0396 return self.__fields
0397
0398
0399 def _update(self, args, kwargs):
0400 super(indexfile,self)._update(args,kwargs)
0401 keys=kwargs.keys()
0402 for key in keys:
0403 if key in self.__fields:
0404 setattr(self, key, kwargs[key])
0405 del kwargs[key]
0406 if __debug__:
0408 self._complainaboutunusedargs(indexfile,kwargs)
0409 if len(args):
0410 dict2={'elementclass': indexentry, 'createdefault': True}
0411 dict2.update(kwargs)
0412 kwargs=dict2
0413 self.__field_items=LIST(*args,**dict2)
0414
0416
0417 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0418 'Writes this packet to the supplied buffer'
0419 self._bufferstartoffset=buf.getcurrentoffset()
0420 try: self.__field_items
0421 except:
0422 self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True})
0423 self.__field_items.writetobuffer(buf)
0424 self._bufferendoffset=buf.getcurrentoffset()
0425 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0426
0427
0428 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0429 'Reads this packet from the supplied buffer'
0430 self._bufferstartoffset=buf.getcurrentoffset()
0431 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0432 self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True})
0433 self.__field_items.readfrombuffer(buf)
0434 self._bufferendoffset=buf.getcurrentoffset()
0435
0436
0437 def __getfield_items(self):
0438 try: self.__field_items
0439 except:
0440 self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True})
0441 return self.__field_items.getvalue()
0442
0443 def __setfield_items(self, value):
0444 if isinstance(value,LIST):
0445 self.__field_items=value
0446 else:
0447 self.__field_items=LIST(value,**{'elementclass': indexentry, 'createdefault': True})
0448
0449 def __delfield_items(self): del self.__field_items
0450
0451 items=property(__getfield_items, __setfield_items, __delfield_items, None)
0452
0453 def iscontainer(self):
0454 return True
0455
0456 def containerelements(self):
0457 yield ('items', self.__field_items, None)
0458
0459
0460
0461
0462 class sizefile(BaseProtogenClass):
0463 "Used for tracking the total size used by a particular type of media"
0464 __fields=['size']
0465
0466 def __init__(self, *args, **kwargs):
0467 dict={}
0468 dict.update(kwargs)
0470 super(sizefile,self).__init__(**dict)
0472 if self.__class__ is sizefile:
0473 self._update(args,dict)
0474
0475
0476 def getfields(self):
0477 return self.__fields
0478
0479
0480 def _update(self, args, kwargs):
0481 super(sizefile,self)._update(args,kwargs)
0482 keys=kwargs.keys()
0483 for key in keys:
0484 if key in self.__fields:
0485 setattr(self, key, kwargs[key])
0486 del kwargs[key]
0487 if __debug__:
0489 self._complainaboutunusedargs(sizefile,kwargs)
0490 if len(args):
0491 dict2={'sizeinbytes': 4}
0492 dict2.update(kwargs)
0493 kwargs=dict2
0494 self.__field_size=UINT(*args,**dict2)
0495
0497
0498 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0499 'Writes this packet to the supplied buffer'
0500 self._bufferstartoffset=buf.getcurrentoffset()
0501 self.__field_size.writetobuffer(buf)
0502 self._bufferendoffset=buf.getcurrentoffset()
0503 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0504
0505
0506 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0507 'Reads this packet from the supplied buffer'
0508 self._bufferstartoffset=buf.getcurrentoffset()
0509 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0510 self.__field_size=UINT(**{'sizeinbytes': 4})
0511 self.__field_size.readfrombuffer(buf)
0512 self._bufferendoffset=buf.getcurrentoffset()
0513
0514
0515 def __getfield_size(self):
0516 return self.__field_size.getvalue()
0517
0518 def __setfield_size(self, value):
0519 if isinstance(value,UINT):
0520 self.__field_size=value
0521 else:
0522 self.__field_size=UINT(value,**{'sizeinbytes': 4})
0523
0524 def __delfield_size(self): del self.__field_size
0525
0526 size=property(__getfield_size, __setfield_size, __delfield_size, None)
0527
0528 def iscontainer(self):
0529 return True
0530
0531 def containerelements(self):
0532 yield ('size', self.__field_size, None)
0533
0534
0535
0536
0537 class pbentry(BaseProtogenClass):
0538 __fields=['serial1', 'entrysize', 'serial2', 'entrynumber', 'name', 'group', 'emails', 'ringtone', 'msgringtone', 'wallpaper', 'numbertypes', 'numbers', 'unknown']
0539
0540 def __init__(self, *args, **kwargs):
0541 dict={}
0542 dict.update(kwargs)
0544 super(pbentry,self).__init__(**dict)
0546 if self.__class__ is pbentry:
0547 self._update(args,dict)
0548
0549
0550 def getfields(self):
0551 return self.__fields
0552
0553
0554 def _update(self, args, kwargs):
0555 super(pbentry,self)._update(args,kwargs)
0556 keys=kwargs.keys()
0557 for key in keys:
0558 if key in self.__fields:
0559 setattr(self, key, kwargs[key])
0560 del kwargs[key]
0561 if __debug__:
0563 self._complainaboutunusedargs(pbentry,kwargs)
0564 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0565
0567
0568 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0569 'Writes this packet to the supplied buffer'
0570 self._bufferstartoffset=buf.getcurrentoffset()
0571 self.__field_serial1.writetobuffer(buf)
0572 try: self.__field_entrysize
0573 except:
0574 self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0x181, 'constantexception': PhoneBookBusyException})
0575 self.__field_entrysize.writetobuffer(buf)
0576 self.__field_serial2.writetobuffer(buf)
0577 self.__field_entrynumber.writetobuffer(buf)
0578 self.__field_name.writetobuffer(buf)
0579 self.__field_group.writetobuffer(buf)
0580 try: self.__field_emails
0581 except:
0582 self.__field_emails=LIST(**{'elementclass': _gen_p_lgvx7000_104, 'length': NUMEMAILS})
0583 self.__field_emails.writetobuffer(buf)
0584 self.__field_ringtone.writetobuffer(buf)
0585 self.__field_msgringtone.writetobuffer(buf)
0586 self.__field_wallpaper.writetobuffer(buf)
0587 try: self.__field_numbertypes
0588 except:
0589 self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lgvx7000_109, 'length': NUMPHONENUMBERS})
0590 self.__field_numbertypes.writetobuffer(buf)
0591 try: self.__field_numbers
0592 except:
0593 self.__field_numbers=LIST(**{'elementclass': _gen_p_lgvx7000_111, 'length': NUMPHONENUMBERS})
0594 self.__field_numbers.writetobuffer(buf)
0595 try: self.__field_unknown
0596 except:
0597 self.__field_unknown=UNKNOWN()
0598 self.__field_unknown.writetobuffer(buf)
0599 self._bufferendoffset=buf.getcurrentoffset()
0600 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0601
0602
0603 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0604 'Reads this packet from the supplied buffer'
0605 self._bufferstartoffset=buf.getcurrentoffset()
0606 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0607 self.__field_serial1=UINT(**{'sizeinbytes': 4})
0608 self.__field_serial1.readfrombuffer(buf)
0609 self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0x181, 'constantexception': PhoneBookBusyException})
0610 self.__field_entrysize.readfrombuffer(buf)
0611 self.__field_serial2=UINT(**{'sizeinbytes': 4})
0612 self.__field_serial2.readfrombuffer(buf)
0613 self.__field_entrynumber=UINT(**{'sizeinbytes': 2})
0614 self.__field_entrynumber.readfrombuffer(buf)
0615 self.__field_name=USTRING(**{'sizeinbytes': 23, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
0616 self.__field_name.readfrombuffer(buf)
0617 self.__field_group=UINT(**{'sizeinbytes': 2})
0618 self.__field_group.readfrombuffer(buf)
0619 self.__field_emails=LIST(**{'elementclass': _gen_p_lgvx7000_104, 'length': NUMEMAILS})
0620 self.__field_emails.readfrombuffer(buf)
0621 self.__field_ringtone=UINT(**{'sizeinbytes': 2})
0622 self.__field_ringtone.readfrombuffer(buf)
0623 self.__field_msgringtone=UINT(**{'sizeinbytes': 2})
0624 self.__field_msgringtone.readfrombuffer(buf)
0625 self.__field_wallpaper=UINT(**{'sizeinbytes': 2})
0626 self.__field_wallpaper.readfrombuffer(buf)
0627 self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lgvx7000_109, 'length': NUMPHONENUMBERS})
0628 self.__field_numbertypes.readfrombuffer(buf)
0629 self.__field_numbers=LIST(**{'elementclass': _gen_p_lgvx7000_111, 'length': NUMPHONENUMBERS})
0630 self.__field_numbers.readfrombuffer(buf)
0631 self.__field_unknown=UNKNOWN()
0632 self.__field_unknown.readfrombuffer(buf)
0633 self._bufferendoffset=buf.getcurrentoffset()
0634
0635
0636 def __getfield_serial1(self):
0637 return self.__field_serial1.getvalue()
0638
0639 def __setfield_serial1(self, value):
0640 if isinstance(value,UINT):
0641 self.__field_serial1=value
0642 else:
0643 self.__field_serial1=UINT(value,**{'sizeinbytes': 4})
0644
0645 def __delfield_serial1(self): del self.__field_serial1
0646
0647 serial1=property(__getfield_serial1, __setfield_serial1, __delfield_serial1, None)
0648
0649 def __getfield_entrysize(self):
0650 try: self.__field_entrysize
0651 except:
0652 self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0x181, 'constantexception': PhoneBookBusyException})
0653 return self.__field_entrysize.getvalue()
0654
0655 def __setfield_entrysize(self, value):
0656 if isinstance(value,UINT):
0657 self.__field_entrysize=value
0658 else:
0659 self.__field_entrysize=UINT(value,**{'sizeinbytes': 2, 'constant': 0x181, 'constantexception': PhoneBookBusyException})
0660
0661 def __delfield_entrysize(self): del self.__field_entrysize
0662
0663 entrysize=property(__getfield_entrysize, __setfield_entrysize, __delfield_entrysize, None)
0664
0665 def __getfield_serial2(self):
0666 return self.__field_serial2.getvalue()
0667
0668 def __setfield_serial2(self, value):
0669 if isinstance(value,UINT):
0670 self.__field_serial2=value
0671 else:
0672 self.__field_serial2=UINT(value,**{'sizeinbytes': 4})
0673
0674 def __delfield_serial2(self): del self.__field_serial2
0675
0676 serial2=property(__getfield_serial2, __setfield_serial2, __delfield_serial2, None)
0677
0678 def __getfield_entrynumber(self):
0679 return self.__field_entrynumber.getvalue()
0680
0681 def __setfield_entrynumber(self, value):
0682 if isinstance(value,UINT):
0683 self.__field_entrynumber=value
0684 else:
0685 self.__field_entrynumber=UINT(value,**{'sizeinbytes': 2})
0686
0687 def __delfield_entrynumber(self): del self.__field_entrynumber
0688
0689 entrynumber=property(__getfield_entrynumber, __setfield_entrynumber, __delfield_entrynumber, None)
0690
0691 def __getfield_name(self):
0692 return self.__field_name.getvalue()
0693
0694 def __setfield_name(self, value):
0695 if isinstance(value,USTRING):
0696 self.__field_name=value
0697 else:
0698 self.__field_name=USTRING(value,**{'sizeinbytes': 23, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
0699
0700 def __delfield_name(self): del self.__field_name
0701
0702 name=property(__getfield_name, __setfield_name, __delfield_name, None)
0703
0704 def __getfield_group(self):
0705 return self.__field_group.getvalue()
0706
0707 def __setfield_group(self, value):
0708 if isinstance(value,UINT):
0709 self.__field_group=value
0710 else:
0711 self.__field_group=UINT(value,**{'sizeinbytes': 2})
0712
0713 def __delfield_group(self): del self.__field_group
0714
0715 group=property(__getfield_group, __setfield_group, __delfield_group, None)
0716
0717 def __getfield_emails(self):
0718 try: self.__field_emails
0719 except:
0720 self.__field_emails=LIST(**{'elementclass': _gen_p_lgvx7000_104, 'length': NUMEMAILS})
0721 return self.__field_emails.getvalue()
0722
0723 def __setfield_emails(self, value):
0724 if isinstance(value,LIST):
0725 self.__field_emails=value
0726 else:
0727 self.__field_emails=LIST(value,**{'elementclass': _gen_p_lgvx7000_104, 'length': NUMEMAILS})
0728
0729 def __delfield_emails(self): del self.__field_emails
0730
0731 emails=property(__getfield_emails, __setfield_emails, __delfield_emails, None)
0732
0733 def __getfield_ringtone(self):
0734 return self.__field_ringtone.getvalue()
0735
0736 def __setfield_ringtone(self, value):
0737 if isinstance(value,UINT):
0738 self.__field_ringtone=value
0739 else:
0740 self.__field_ringtone=UINT(value,**{'sizeinbytes': 2})
0741
0742 def __delfield_ringtone(self): del self.__field_ringtone
0743
0744 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, "ringtone index for a call")
0745
0746 def __getfield_msgringtone(self):
0747 return self.__field_msgringtone.getvalue()
0748
0749 def __setfield_msgringtone(self, value):
0750 if isinstance(value,UINT):
0751 self.__field_msgringtone=value
0752 else:
0753 self.__field_msgringtone=UINT(value,**{'sizeinbytes': 2})
0754
0755 def __delfield_msgringtone(self): del self.__field_msgringtone
0756
0757 msgringtone=property(__getfield_msgringtone, __setfield_msgringtone, __delfield_msgringtone, "ringtone index for a text message")
0758
0759 def __getfield_wallpaper(self):
0760 return self.__field_wallpaper.getvalue()
0761
0762 def __setfield_wallpaper(self, value):
0763 if isinstance(value,UINT):
0764 self.__field_wallpaper=value
0765 else:
0766 self.__field_wallpaper=UINT(value,**{'sizeinbytes': 2})
0767
0768 def __delfield_wallpaper(self): del self.__field_wallpaper
0769
0770 wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None)
0771
0772 def __getfield_numbertypes(self):
0773 try: self.__field_numbertypes
0774 except:
0775 self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lgvx7000_109, 'length': NUMPHONENUMBERS})
0776 return self.__field_numbertypes.getvalue()
0777
0778 def __setfield_numbertypes(self, value):
0779 if isinstance(value,LIST):
0780 self.__field_numbertypes=value
0781 else:
0782 self.__field_numbertypes=LIST(value,**{'elementclass': _gen_p_lgvx7000_109, 'length': NUMPHONENUMBERS})
0783
0784 def __delfield_numbertypes(self): del self.__field_numbertypes
0785
0786 numbertypes=property(__getfield_numbertypes, __setfield_numbertypes, __delfield_numbertypes, None)
0787
0788 def __getfield_numbers(self):
0789 try: self.__field_numbers
0790 except:
0791 self.__field_numbers=LIST(**{'elementclass': _gen_p_lgvx7000_111, 'length': NUMPHONENUMBERS})
0792 return self.__field_numbers.getvalue()
0793
0794 def __setfield_numbers(self, value):
0795 if isinstance(value,LIST):
0796 self.__field_numbers=value
0797 else:
0798 self.__field_numbers=LIST(value,**{'elementclass': _gen_p_lgvx7000_111, 'length': NUMPHONENUMBERS})
0799
0800 def __delfield_numbers(self): del self.__field_numbers
0801
0802 numbers=property(__getfield_numbers, __setfield_numbers, __delfield_numbers, None)
0803
0804 def __getfield_unknown(self):
0805 try: self.__field_unknown
0806 except:
0807 self.__field_unknown=UNKNOWN()
0808 return self.__field_unknown.getvalue()
0809
0810 def __setfield_unknown(self, value):
0811 if isinstance(value,UNKNOWN):
0812 self.__field_unknown=value
0813 else:
0814 self.__field_unknown=UNKNOWN(value,)
0815
0816 def __delfield_unknown(self): del self.__field_unknown
0817
0818 unknown=property(__getfield_unknown, __setfield_unknown, __delfield_unknown, None)
0819
0820 def iscontainer(self):
0821 return True
0822
0823 def containerelements(self):
0824 yield ('serial1', self.__field_serial1, None)
0825 yield ('entrysize', self.__field_entrysize, None)
0826 yield ('serial2', self.__field_serial2, None)
0827 yield ('entrynumber', self.__field_entrynumber, None)
0828 yield ('name', self.__field_name, None)
0829 yield ('group', self.__field_group, None)
0830 yield ('emails', self.__field_emails, None)
0831 yield ('ringtone', self.__field_ringtone, "ringtone index for a call")
0832 yield ('msgringtone', self.__field_msgringtone, "ringtone index for a text message")
0833 yield ('wallpaper', self.__field_wallpaper, None)
0834 yield ('numbertypes', self.__field_numbertypes, None)
0835 yield ('numbers', self.__field_numbers, None)
0836 yield ('unknown', self.__field_unknown, None)
0837
0838
0839
0840
0841 class _gen_p_lgvx7000_104(BaseProtogenClass):
0842 'Anonymous inner class'
0843 __fields=['email']
0844
0845 def __init__(self, *args, **kwargs):
0846 dict={}
0847 dict.update(kwargs)
0849 super(_gen_p_lgvx7000_104,self).__init__(**dict)
0851 if self.__class__ is _gen_p_lgvx7000_104:
0852 self._update(args,dict)
0853
0854
0855 def getfields(self):
0856 return self.__fields
0857
0858
0859 def _update(self, args, kwargs):
0860 super(_gen_p_lgvx7000_104,self)._update(args,kwargs)
0861 keys=kwargs.keys()
0862 for key in keys:
0863 if key in self.__fields:
0864 setattr(self, key, kwargs[key])
0865 del kwargs[key]
0866 if __debug__:
0868 self._complainaboutunusedargs(_gen_p_lgvx7000_104,kwargs)
0869 if len(args):
0870 dict2={'sizeinbytes': 49, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}
0871 dict2.update(kwargs)
0872 kwargs=dict2
0873 self.__field_email=USTRING(*args,**dict2)
0874
0876
0877 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0878 'Writes this packet to the supplied buffer'
0879 self._bufferstartoffset=buf.getcurrentoffset()
0880 self.__field_email.writetobuffer(buf)
0881 self._bufferendoffset=buf.getcurrentoffset()
0882 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0883
0884
0885 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0886 'Reads this packet from the supplied buffer'
0887 self._bufferstartoffset=buf.getcurrentoffset()
0888 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0889 self.__field_email=USTRING(**{'sizeinbytes': 49, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
0890 self.__field_email.readfrombuffer(buf)
0891 self._bufferendoffset=buf.getcurrentoffset()
0892
0893
0894 def __getfield_email(self):
0895 return self.__field_email.getvalue()
0896
0897 def __setfield_email(self, value):
0898 if isinstance(value,USTRING):
0899 self.__field_email=value
0900 else:
0901 self.__field_email=USTRING(value,**{'sizeinbytes': 49, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
0902
0903 def __delfield_email(self): del self.__field_email
0904
0905 email=property(__getfield_email, __setfield_email, __delfield_email, None)
0906
0907 def iscontainer(self):
0908 return True
0909
0910 def containerelements(self):
0911 yield ('email', self.__field_email, None)
0912
0913
0914
0915
0916 class _gen_p_lgvx7000_109(BaseProtogenClass):
0917 'Anonymous inner class'
0918 __fields=['numbertype']
0919
0920 def __init__(self, *args, **kwargs):
0921 dict={}
0922 dict.update(kwargs)
0924 super(_gen_p_lgvx7000_109,self).__init__(**dict)
0926 if self.__class__ is _gen_p_lgvx7000_109:
0927 self._update(args,dict)
0928
0929
0930 def getfields(self):
0931 return self.__fields
0932
0933
0934 def _update(self, args, kwargs):
0935 super(_gen_p_lgvx7000_109,self)._update(args,kwargs)
0936 keys=kwargs.keys()
0937 for key in keys:
0938 if key in self.__fields:
0939 setattr(self, key, kwargs[key])
0940 del kwargs[key]
0941 if __debug__:
0943 self._complainaboutunusedargs(_gen_p_lgvx7000_109,kwargs)
0944 if len(args):
0945 dict2={'sizeinbytes': 1}
0946 dict2.update(kwargs)
0947 kwargs=dict2
0948 self.__field_numbertype=UINT(*args,**dict2)
0949
0951
0952 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0953 'Writes this packet to the supplied buffer'
0954 self._bufferstartoffset=buf.getcurrentoffset()
0955 self.__field_numbertype.writetobuffer(buf)
0956 self._bufferendoffset=buf.getcurrentoffset()
0957 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0958
0959
0960 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0961 'Reads this packet from the supplied buffer'
0962 self._bufferstartoffset=buf.getcurrentoffset()
0963 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0964 self.__field_numbertype=UINT(**{'sizeinbytes': 1})
0965 self.__field_numbertype.readfrombuffer(buf)
0966 self._bufferendoffset=buf.getcurrentoffset()
0967
0968
0969 def __getfield_numbertype(self):
0970 return self.__field_numbertype.getvalue()
0971
0972 def __setfield_numbertype(self, value):
0973 if isinstance(value,UINT):
0974 self.__field_numbertype=value
0975 else:
0976 self.__field_numbertype=UINT(value,**{'sizeinbytes': 1})
0977
0978 def __delfield_numbertype(self): del self.__field_numbertype
0979
0980 numbertype=property(__getfield_numbertype, __setfield_numbertype, __delfield_numbertype, None)
0981
0982 def iscontainer(self):
0983 return True
0984
0985 def containerelements(self):
0986 yield ('numbertype', self.__field_numbertype, None)
0987
0988
0989
0990
0991 class _gen_p_lgvx7000_111(BaseProtogenClass):
0992 'Anonymous inner class'
0993 __fields=['number']
0994
0995 def __init__(self, *args, **kwargs):
0996 dict={}
0997 dict.update(kwargs)
0999 super(_gen_p_lgvx7000_111,self).__init__(**dict)
1001 if self.__class__ is _gen_p_lgvx7000_111:
1002 self._update(args,dict)
1003
1004
1005 def getfields(self):
1006 return self.__fields
1007
1008
1009 def _update(self, args, kwargs):
1010 super(_gen_p_lgvx7000_111,self)._update(args,kwargs)
1011 keys=kwargs.keys()
1012 for key in keys:
1013 if key in self.__fields:
1014 setattr(self, key, kwargs[key])
1015 del kwargs[key]
1016 if __debug__:
1018 self._complainaboutunusedargs(_gen_p_lgvx7000_111,kwargs)
1019 if len(args):
1020 dict2={'sizeinbytes': 49, 'raiseonunterminatedread': False}
1021 dict2.update(kwargs)
1022 kwargs=dict2
1023 self.__field_number=USTRING(*args,**dict2)
1024
1026
1027 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1028 'Writes this packet to the supplied buffer'
1029 self._bufferstartoffset=buf.getcurrentoffset()
1030 self.__field_number.writetobuffer(buf)
1031 self._bufferendoffset=buf.getcurrentoffset()
1032 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1033
1034
1035 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1036 'Reads this packet from the supplied buffer'
1037 self._bufferstartoffset=buf.getcurrentoffset()
1038 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1039 self.__field_number=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
1040 self.__field_number.readfrombuffer(buf)
1041 self._bufferendoffset=buf.getcurrentoffset()
1042
1043
1044 def __getfield_number(self):
1045 return self.__field_number.getvalue()
1046
1047 def __setfield_number(self, value):
1048 if isinstance(value,USTRING):
1049 self.__field_number=value
1050 else:
1051 self.__field_number=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
1052
1053 def __delfield_number(self): del self.__field_number
1054
1055 number=property(__getfield_number, __setfield_number, __delfield_number, None)
1056
1057 def iscontainer(self):
1058 return True
1059
1060 def containerelements(self):
1061 yield ('number', self.__field_number, None)
1062
1063
1064
1065
1066 class pbreadentryresponse(BaseProtogenClass):
1067 "Results of reading one entry"
1068 __fields=['header', 'entry']
1069
1070 def __init__(self, *args, **kwargs):
1071 dict={}
1072 dict.update(kwargs)
1074 super(pbreadentryresponse,self).__init__(**dict)
1076 if self.__class__ is pbreadentryresponse:
1077 self._update(args,dict)
1078
1079
1080 def getfields(self):
1081 return self.__fields
1082
1083
1084 def _update(self, args, kwargs):
1085 super(pbreadentryresponse,self)._update(args,kwargs)
1086 keys=kwargs.keys()
1087 for key in keys:
1088 if key in self.__fields:
1089 setattr(self, key, kwargs[key])
1090 del kwargs[key]
1091 if __debug__:
1093 self._complainaboutunusedargs(pbreadentryresponse,kwargs)
1094 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1095
1097
1098 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1099 'Writes this packet to the supplied buffer'
1100 self._bufferstartoffset=buf.getcurrentoffset()
1101 self.__field_header.writetobuffer(buf)
1102 self.__field_entry.writetobuffer(buf)
1103 self._bufferendoffset=buf.getcurrentoffset()
1104 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1105
1106
1107 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1108 'Reads this packet from the supplied buffer'
1109 self._bufferstartoffset=buf.getcurrentoffset()
1110 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1111 self.__field_header=pbheader()
1112 self.__field_header.readfrombuffer(buf)
1113 self.__field_entry=pbentry()
1114 self.__field_entry.readfrombuffer(buf)
1115 self._bufferendoffset=buf.getcurrentoffset()
1116
1117
1118 def __getfield_header(self):
1119 return self.__field_header.getvalue()
1120
1121 def __setfield_header(self, value):
1122 if isinstance(value,pbheader):
1123 self.__field_header=value
1124 else:
1125 self.__field_header=pbheader(value,)
1126
1127 def __delfield_header(self): del self.__field_header
1128
1129 header=property(__getfield_header, __setfield_header, __delfield_header, None)
1130
1131 def __getfield_entry(self):
1132 return self.__field_entry.getvalue()
1133
1134 def __setfield_entry(self, value):
1135 if isinstance(value,pbentry):
1136 self.__field_entry=value
1137 else:
1138 self.__field_entry=pbentry(value,)
1139
1140 def __delfield_entry(self): del self.__field_entry
1141
1142 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
1143
1144 def iscontainer(self):
1145 return True
1146
1147 def containerelements(self):
1148 yield ('header', self.__field_header, None)
1149 yield ('entry', self.__field_entry, None)
1150
1151
1152
1153
1154 class pbupdateentryrequest(BaseProtogenClass):
1155 __fields=['header', 'entry']
1156
1157 def __init__(self, *args, **kwargs):
1158 dict={}
1159 dict.update(kwargs)
1161 super(pbupdateentryrequest,self).__init__(**dict)
1163 if self.__class__ is pbupdateentryrequest:
1164 self._update(args,dict)
1165
1166
1167 def getfields(self):
1168 return self.__fields
1169
1170
1171 def _update(self, args, kwargs):
1172 super(pbupdateentryrequest,self)._update(args,kwargs)
1173 keys=kwargs.keys()
1174 for key in keys:
1175 if key in self.__fields:
1176 setattr(self, key, kwargs[key])
1177 del kwargs[key]
1178 if __debug__:
1180 self._complainaboutunusedargs(pbupdateentryrequest,kwargs)
1181 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1182
1184
1185 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1186 'Writes this packet to the supplied buffer'
1187 self._bufferstartoffset=buf.getcurrentoffset()
1188 try: self.__field_header
1189 except:
1190 self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01})
1191 self.__field_header.writetobuffer(buf)
1192 self.__field_entry.writetobuffer(buf)
1193 self._bufferendoffset=buf.getcurrentoffset()
1194 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1195
1196
1197 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1198 'Reads this packet from the supplied buffer'
1199 self._bufferstartoffset=buf.getcurrentoffset()
1200 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1201 self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01})
1202 self.__field_header.readfrombuffer(buf)
1203 self.__field_entry=pbentry()
1204 self.__field_entry.readfrombuffer(buf)
1205 self._bufferendoffset=buf.getcurrentoffset()
1206
1207
1208 def __getfield_header(self):
1209 try: self.__field_header
1210 except:
1211 self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01})
1212 return self.__field_header.getvalue()
1213
1214 def __setfield_header(self, value):
1215 if isinstance(value,pbheader):
1216 self.__field_header=value
1217 else:
1218 self.__field_header=pbheader(value,**{'command': 0x04, 'flag': 0x01})
1219
1220 def __delfield_header(self): del self.__field_header
1221
1222 header=property(__getfield_header, __setfield_header, __delfield_header, None)
1223
1224 def __getfield_entry(self):
1225 return self.__field_entry.getvalue()
1226
1227 def __setfield_entry(self, value):
1228 if isinstance(value,pbentry):
1229 self.__field_entry=value
1230 else:
1231 self.__field_entry=pbentry(value,)
1232
1233 def __delfield_entry(self): del self.__field_entry
1234
1235 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
1236
1237 def iscontainer(self):
1238 return True
1239
1240 def containerelements(self):
1241 yield ('header', self.__field_header, None)
1242 yield ('entry', self.__field_entry, None)
1243
1244
1245
1246
1247 class pbappendentryrequest(BaseProtogenClass):
1248 __fields=['header', 'entry']
1249
1250 def __init__(self, *args, **kwargs):
1251 dict={}
1252 dict.update(kwargs)
1254 super(pbappendentryrequest,self).__init__(**dict)
1256 if self.__class__ is pbappendentryrequest:
1257 self._update(args,dict)
1258
1259
1260 def getfields(self):
1261 return self.__fields
1262
1263
1264 def _update(self, args, kwargs):
1265 super(pbappendentryrequest,self)._update(args,kwargs)
1266 keys=kwargs.keys()
1267 for key in keys:
1268 if key in self.__fields:
1269 setattr(self, key, kwargs[key])
1270 del kwargs[key]
1271 if __debug__:
1273 self._complainaboutunusedargs(pbappendentryrequest,kwargs)
1274 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1275
1277
1278 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1279 'Writes this packet to the supplied buffer'
1280 self._bufferstartoffset=buf.getcurrentoffset()
1281 try: self.__field_header
1282 except:
1283 self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01})
1284 self.__field_header.writetobuffer(buf)
1285 self.__field_entry.writetobuffer(buf)
1286 self._bufferendoffset=buf.getcurrentoffset()
1287 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1288
1289
1290 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1291 'Reads this packet from the supplied buffer'
1292 self._bufferstartoffset=buf.getcurrentoffset()
1293 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1294 self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01})
1295 self.__field_header.readfrombuffer(buf)
1296 self.__field_entry=pbentry()
1297 self.__field_entry.readfrombuffer(buf)
1298 self._bufferendoffset=buf.getcurrentoffset()
1299
1300
1301 def __getfield_header(self):
1302 try: self.__field_header
1303 except:
1304 self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01})
1305 return self.__field_header.getvalue()
1306
1307 def __setfield_header(self, value):
1308 if isinstance(value,pbheader):
1309 self.__field_header=value
1310 else:
1311 self.__field_header=pbheader(value,**{'command': 0x03, 'flag': 0x01})
1312
1313 def __delfield_header(self): del self.__field_header
1314
1315 header=property(__getfield_header, __setfield_header, __delfield_header, None)
1316
1317 def __getfield_entry(self):
1318 return self.__field_entry.getvalue()
1319
1320 def __setfield_entry(self, value):
1321 if isinstance(value,pbentry):
1322 self.__field_entry=value
1323 else:
1324 self.__field_entry=pbentry(value,)
1325
1326 def __delfield_entry(self): del self.__field_entry
1327
1328 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
1329
1330 def iscontainer(self):
1331 return True
1332
1333 def containerelements(self):
1334 yield ('header', self.__field_header, None)
1335 yield ('entry', self.__field_entry, None)
1336
1337
1338
1339
1340 class scheduleexception(BaseProtogenClass):
1341 __fields=['pos', 'day', 'month', 'year']
1342
1343 def __init__(self, *args, **kwargs):
1344 dict={}
1345 dict.update(kwargs)
1347 super(scheduleexception,self).__init__(**dict)
1349 if self.__class__ is scheduleexception:
1350 self._update(args,dict)
1351
1352
1353 def getfields(self):
1354 return self.__fields
1355
1356
1357 def _update(self, args, kwargs):
1358 super(scheduleexception,self)._update(args,kwargs)
1359 keys=kwargs.keys()
1360 for key in keys:
1361 if key in self.__fields:
1362 setattr(self, key, kwargs[key])
1363 del kwargs[key]
1364 if __debug__:
1366 self._complainaboutunusedargs(scheduleexception,kwargs)
1367 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1368
1370
1371 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1372 'Writes this packet to the supplied buffer'
1373 self._bufferstartoffset=buf.getcurrentoffset()
1374 self.__field_pos.writetobuffer(buf)
1375 self.__field_day.writetobuffer(buf)
1376 self.__field_month.writetobuffer(buf)
1377 self.__field_year.writetobuffer(buf)
1378 self._bufferendoffset=buf.getcurrentoffset()
1379 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1380
1381
1382 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1383 'Reads this packet from the supplied buffer'
1384 self._bufferstartoffset=buf.getcurrentoffset()
1385 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1386 self.__field_pos=UINT(**{'sizeinbytes': 4})
1387 self.__field_pos.readfrombuffer(buf)
1388 self.__field_day=UINT(**{'sizeinbytes': 1})
1389 self.__field_day.readfrombuffer(buf)
1390 self.__field_month=UINT(**{'sizeinbytes': 1})
1391 self.__field_month.readfrombuffer(buf)
1392 self.__field_year=UINT(**{'sizeinbytes': 2})
1393 self.__field_year.readfrombuffer(buf)
1394 self._bufferendoffset=buf.getcurrentoffset()
1395
1396
1397 def __getfield_pos(self):
1398 return self.__field_pos.getvalue()
1399
1400 def __setfield_pos(self, value):
1401 if isinstance(value,UINT):
1402 self.__field_pos=value
1403 else:
1404 self.__field_pos=UINT(value,**{'sizeinbytes': 4})
1405
1406 def __delfield_pos(self): del self.__field_pos
1407
1408 pos=property(__getfield_pos, __setfield_pos, __delfield_pos, "Refers to event id (position in schedule file) that this suppresses")
1409
1410 def __getfield_day(self):
1411 return self.__field_day.getvalue()
1412
1413 def __setfield_day(self, value):
1414 if isinstance(value,UINT):
1415 self.__field_day=value
1416 else:
1417 self.__field_day=UINT(value,**{'sizeinbytes': 1})
1418
1419 def __delfield_day(self): del self.__field_day
1420
1421 day=property(__getfield_day, __setfield_day, __delfield_day, None)
1422
1423 def __getfield_month(self):
1424 return self.__field_month.getvalue()
1425
1426 def __setfield_month(self, value):
1427 if isinstance(value,UINT):
1428 self.__field_month=value
1429 else:
1430 self.__field_month=UINT(value,**{'sizeinbytes': 1})
1431
1432 def __delfield_month(self): del self.__field_month
1433
1434 month=property(__getfield_month, __setfield_month, __delfield_month, None)
1435
1436 def __getfield_year(self):
1437 return self.__field_year.getvalue()
1438
1439 def __setfield_year(self, value):
1440 if isinstance(value,UINT):
1441 self.__field_year=value
1442 else:
1443 self.__field_year=UINT(value,**{'sizeinbytes': 2})
1444
1445 def __delfield_year(self): del self.__field_year
1446
1447 year=property(__getfield_year, __setfield_year, __delfield_year, None)
1448
1449 def iscontainer(self):
1450 return True
1451
1452 def containerelements(self):
1453 yield ('pos', self.__field_pos, "Refers to event id (position in schedule file) that this suppresses")
1454 yield ('day', self.__field_day, None)
1455 yield ('month', self.__field_month, None)
1456 yield ('year', self.__field_year, None)
1457
1458
1459
1460
1461 class scheduleexceptionfile(BaseProtogenClass):
1462 __fields=['items']
1463
1464 def __init__(self, *args, **kwargs):
1465 dict={}
1466 dict.update(kwargs)
1468 super(scheduleexceptionfile,self).__init__(**dict)
1470 if self.__class__ is scheduleexceptionfile:
1471 self._update(args,dict)
1472
1473
1474 def getfields(self):
1475 return self.__fields
1476
1477
1478 def _update(self, args, kwargs):
1479 super(scheduleexceptionfile,self)._update(args,kwargs)
1480 keys=kwargs.keys()
1481 for key in keys:
1482 if key in self.__fields:
1483 setattr(self, key, kwargs[key])
1484 del kwargs[key]
1485 if __debug__:
1487 self._complainaboutunusedargs(scheduleexceptionfile,kwargs)
1488 if len(args):
1489 dict2={'elementclass': scheduleexception}
1490 dict2.update(kwargs)
1491 kwargs=dict2
1492 self.__field_items=LIST(*args,**dict2)
1493
1495
1496 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1497 'Writes this packet to the supplied buffer'
1498 self._bufferstartoffset=buf.getcurrentoffset()
1499 try: self.__field_items
1500 except:
1501 self.__field_items=LIST(**{'elementclass': scheduleexception})
1502 self.__field_items.writetobuffer(buf)
1503 self._bufferendoffset=buf.getcurrentoffset()
1504 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1505
1506
1507 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1508 'Reads this packet from the supplied buffer'
1509 self._bufferstartoffset=buf.getcurrentoffset()
1510 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1511 self.__field_items=LIST(**{'elementclass': scheduleexception})
1512 self.__field_items.readfrombuffer(buf)
1513 self._bufferendoffset=buf.getcurrentoffset()
1514
1515
1516 def __getfield_items(self):
1517 try: self.__field_items
1518 except:
1519 self.__field_items=LIST(**{'elementclass': scheduleexception})
1520 return self.__field_items.getvalue()
1521
1522 def __setfield_items(self, value):
1523 if isinstance(value,LIST):
1524 self.__field_items=value
1525 else:
1526 self.__field_items=LIST(value,**{'elementclass': scheduleexception})
1527
1528 def __delfield_items(self): del self.__field_items
1529
1530 items=property(__getfield_items, __setfield_items, __delfield_items, None)
1531
1532 def iscontainer(self):
1533 return True
1534
1535 def containerelements(self):
1536 yield ('items', self.__field_items, None)
1537
1538
1539
1540
1541 class scheduleevent(BaseProtogenClass):
1542 __fields=['pos', 'start', 'end', 'repeat', 'daybitmap', 'alarmminutes', 'alarmhours', 'alarmtype', 'snoozedelay', 'ringtone', 'pad2', 'description']
1543
1544 def __init__(self, *args, **kwargs):
1545 dict={}
1546 dict.update(kwargs)
1548 super(scheduleevent,self).__init__(**dict)
1550 if self.__class__ is scheduleevent:
1551 self._update(args,dict)
1552
1553
1554 def getfields(self):
1555 return self.__fields
1556
1557
1558 def _update(self, args, kwargs):
1559 super(scheduleevent,self)._update(args,kwargs)
1560 keys=kwargs.keys()
1561 for key in keys:
1562 if key in self.__fields:
1563 setattr(self, key, kwargs[key])
1564 del kwargs[key]
1565 if __debug__:
1567 self._complainaboutunusedargs(scheduleevent,kwargs)
1568 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1569
1571
1572 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1573 'Writes this packet to the supplied buffer'
1574 self._bufferstartoffset=buf.getcurrentoffset()
1575 self.__field_pos.writetobuffer(buf)
1576 self.__field_start.writetobuffer(buf)
1577 self.__field_end.writetobuffer(buf)
1578 self.__field_repeat.writetobuffer(buf)
1579 self.__field_daybitmap.writetobuffer(buf)
1580 self.__field_alarmminutes.writetobuffer(buf)
1581 self.__field_alarmhours.writetobuffer(buf)
1582 self.__field_alarmtype.writetobuffer(buf)
1583 try: self.__field_snoozedelay
1584 except:
1585 self.__field_snoozedelay=UINT(**{'sizeinbytes': 1, 'default': 0 })
1586 self.__field_snoozedelay.writetobuffer(buf)
1587 self.__field_ringtone.writetobuffer(buf)
1588 try: self.__field_pad2
1589 except:
1590 self.__field_pad2=UINT(**{'sizeinbytes': 4, 'default': 0 })
1591 self.__field_pad2.writetobuffer(buf)
1592 self.__field_description.writetobuffer(buf)
1593 self._bufferendoffset=buf.getcurrentoffset()
1594 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1595
1596
1597 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1598 'Reads this packet from the supplied buffer'
1599 self._bufferstartoffset=buf.getcurrentoffset()
1600 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1601 self.__field_pos=UINT(**{'sizeinbytes': 4})
1602 self.__field_pos.readfrombuffer(buf)
1603 self.__field_start=LGCALDATE(**{'sizeinbytes': 4})
1604 self.__field_start.readfrombuffer(buf)
1605 self.__field_end=LGCALDATE(**{'sizeinbytes': 4})
1606 self.__field_end.readfrombuffer(buf)
1607 self.__field_repeat=UINT(**{'sizeinbytes': 1})
1608 self.__field_repeat.readfrombuffer(buf)
1609 self.__field_daybitmap=UINT(**{'sizeinbytes': 2})
1610 self.__field_daybitmap.readfrombuffer(buf)
1611 self.__field_alarmminutes=UINT(**{'sizeinbytes': 1})
1612 self.__field_alarmminutes.readfrombuffer(buf)
1613 self.__field_alarmhours=UINT(**{'sizeinbytes': 1})
1614 self.__field_alarmhours.readfrombuffer(buf)
1615 self.__field_alarmtype=UINT(**{'sizeinbytes': 1})
1616 self.__field_alarmtype.readfrombuffer(buf)
1617 self.__field_snoozedelay=UINT(**{'sizeinbytes': 1, 'default': 0 })
1618 self.__field_snoozedelay.readfrombuffer(buf)
1619 self.__field_ringtone=UINT(**{'sizeinbytes': 1})
1620 self.__field_ringtone.readfrombuffer(buf)
1621 self.__field_pad2=UINT(**{'sizeinbytes': 4, 'default': 0 })
1622 self.__field_pad2.readfrombuffer(buf)
1623 self.__field_description=USTRING(**{'sizeinbytes': 39, 'encoding': PHONE_ENCODING, 'raiseontruncate': False, 'raiseonunterminatedread': False })
1624 self.__field_description.readfrombuffer(buf)
1625 self._bufferendoffset=buf.getcurrentoffset()
1626
1627
1628 def __getfield_pos(self):
1629 return self.__field_pos.getvalue()
1630
1631 def __setfield_pos(self, value):
1632 if isinstance(value,UINT):
1633 self.__field_pos=value
1634 else:
1635 self.__field_pos=UINT(value,**{'sizeinbytes': 4})
1636
1637 def __delfield_pos(self): del self.__field_pos
1638
1639 pos=property(__getfield_pos, __setfield_pos, __delfield_pos, "position within file, used as an event id")
1640
1641 def __getfield_start(self):
1642 return self.__field_start.getvalue()
1643
1644 def __setfield_start(self, value):
1645 if isinstance(value,LGCALDATE):
1646 self.__field_start=value
1647 else:
1648 self.__field_start=LGCALDATE(value,**{'sizeinbytes': 4})
1649
1650 def __delfield_start(self): del self.__field_start
1651
1652 start=property(__getfield_start, __setfield_start, __delfield_start, None)
1653
1654 def __getfield_end(self):
1655 return self.__field_end.getvalue()
1656
1657 def __setfield_end(self, value):
1658 if isinstance(value,LGCALDATE):
1659 self.__field_end=value
1660 else:
1661 self.__field_end=LGCALDATE(value,**{'sizeinbytes': 4})
1662
1663 def __delfield_end(self): del self.__field_end
1664
1665 end=property(__getfield_end, __setfield_end, __delfield_end, None)
1666
1667 def __getfield_repeat(self):
1668 return self.__field_repeat.getvalue()
1669
1670 def __setfield_repeat(self, value):
1671 if isinstance(value,UINT):
1672 self.__field_repeat=value
1673 else:
1674 self.__field_repeat=UINT(value,**{'sizeinbytes': 1})
1675
1676 def __delfield_repeat(self): del self.__field_repeat
1677
1678 repeat=property(__getfield_repeat, __setfield_repeat, __delfield_repeat, None)
1679
1680 def __getfield_daybitmap(self):
1681 return self.__field_daybitmap.getvalue()
1682
1683 def __setfield_daybitmap(self, value):
1684 if isinstance(value,UINT):
1685 self.__field_daybitmap=value
1686 else:
1687 self.__field_daybitmap=UINT(value,**{'sizeinbytes': 2})
1688
1689 def __delfield_daybitmap(self): del self.__field_daybitmap
1690
1691 daybitmap=property(__getfield_daybitmap, __setfield_daybitmap, __delfield_daybitmap, "which days a weekly repeat event happens on")
1692
1693 def __getfield_alarmminutes(self):
1694 return self.__field_alarmminutes.getvalue()
1695
1696 def __setfield_alarmminutes(self, value):
1697 if isinstance(value,UINT):
1698 self.__field_alarmminutes=value
1699 else:
1700 self.__field_alarmminutes=UINT(value,**{'sizeinbytes': 1})
1701
1702 def __delfield_alarmminutes(self): del self.__field_alarmminutes
1703
1704 alarmminutes=property(__getfield_alarmminutes, __setfield_alarmminutes, __delfield_alarmminutes, "a value of 100 indicates not set")
1705
1706 def __getfield_alarmhours(self):
1707 return self.__field_alarmhours.getvalue()
1708
1709 def __setfield_alarmhours(self, value):
1710 if isinstance(value,UINT):
1711 self.__field_alarmhours=value
1712 else:
1713 self.__field_alarmhours=UINT(value,**{'sizeinbytes': 1})
1714
1715 def __delfield_alarmhours(self): del self.__field_alarmhours
1716
1717 alarmhours=property(__getfield_alarmhours, __setfield_alarmhours, __delfield_alarmhours, "a value of 100 indicates not set")
1718
1719 def __getfield_alarmtype(self):
1720 return self.__field_alarmtype.getvalue()
1721
1722 def __setfield_alarmtype(self, value):
1723 if isinstance(value,UINT):
1724 self.__field_alarmtype=value
1725 else:
1726 self.__field_alarmtype=UINT(value,**{'sizeinbytes': 1})
1727
1728 def __delfield_alarmtype(self): del self.__field_alarmtype
1729
1730 alarmtype=property(__getfield_alarmtype, __setfield_alarmtype, __delfield_alarmtype, "preset alarm reminder type")
1731
1732 def __getfield_snoozedelay(self):
1733 try: self.__field_snoozedelay
1734 except:
1735 self.__field_snoozedelay=UINT(**{'sizeinbytes': 1, 'default': 0 })
1736 return self.__field_snoozedelay.getvalue()
1737
1738 def __setfield_snoozedelay(self, value):
1739 if isinstance(value,UINT):
1740 self.__field_snoozedelay=value
1741 else:
1742 self.__field_snoozedelay=UINT(value,**{'sizeinbytes': 1, 'default': 0 })
1743
1744 def __delfield_snoozedelay(self): del self.__field_snoozedelay
1745
1746 snoozedelay=property(__getfield_snoozedelay, __setfield_snoozedelay, __delfield_snoozedelay, "in minutes, not for this phone")
1747
1748 def __getfield_ringtone(self):
1749 return self.__field_ringtone.getvalue()
1750
1751 def __setfield_ringtone(self, value):
1752 if isinstance(value,UINT):
1753 self.__field_ringtone=value
1754 else:
1755 self.__field_ringtone=UINT(value,**{'sizeinbytes': 1})
1756
1757 def __delfield_ringtone(self): del self.__field_ringtone
1758
1759 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None)
1760
1761 def __getfield_pad2(self):
1762 try: self.__field_pad2
1763 except:
1764 self.__field_pad2=UINT(**{'sizeinbytes': 4, 'default': 0 })
1765 return self.__field_pad2.getvalue()
1766
1767 def __setfield_pad2(self, value):
1768 if isinstance(value,UINT):
1769 self.__field_pad2=value
1770 else:
1771 self.__field_pad2=UINT(value,**{'sizeinbytes': 4, 'default': 0 })
1772
1773 def __delfield_pad2(self): del self.__field_pad2
1774
1775 pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None)
1776
1777 def __getfield_description(self):
1778 return self.__field_description.getvalue()
1779
1780 def __setfield_description(self, value):
1781 if isinstance(value,USTRING):
1782 self.__field_description=value
1783 else:
1784 self.__field_description=USTRING(value,**{'sizeinbytes': 39, 'encoding': PHONE_ENCODING, 'raiseontruncate': False, 'raiseonunterminatedread': False })
1785
1786 def __delfield_description(self): del self.__field_description
1787
1788 description=property(__getfield_description, __setfield_description, __delfield_description, None)
1789
1790 def iscontainer(self):
1791 return True
1792
1793 def containerelements(self):
1794 yield ('pos', self.__field_pos, "position within file, used as an event id")
1795 yield ('start', self.__field_start, None)
1796 yield ('end', self.__field_end, None)
1797 yield ('repeat', self.__field_repeat, None)
1798 yield ('daybitmap', self.__field_daybitmap, "which days a weekly repeat event happens on")
1799 yield ('alarmminutes', self.__field_alarmminutes, "a value of 100 indicates not set")
1800 yield ('alarmhours', self.__field_alarmhours, "a value of 100 indicates not set")
1801 yield ('alarmtype', self.__field_alarmtype, "preset alarm reminder type")
1802 yield ('snoozedelay', self.__field_snoozedelay, "in minutes, not for this phone")
1803 yield ('ringtone', self.__field_ringtone, None)
1804 yield ('pad2', self.__field_pad2, None)
1805 yield ('description', self.__field_description, None)
1806
1807
1808
1809
1810 class schedulefile(BaseProtogenClass):
1811 __fields=['numactiveitems', 'events']
1812
1813 def __init__(self, *args, **kwargs):
1814 dict={}
1815 dict.update(kwargs)
1817 super(schedulefile,self).__init__(**dict)
1819 if self.__class__ is schedulefile:
1820 self._update(args,dict)
1821
1822
1823 def getfields(self):
1824 return self.__fields
1825
1826
1827 def _update(self, args, kwargs):
1828 super(schedulefile,self)._update(args,kwargs)
1829 keys=kwargs.keys()
1830 for key in keys:
1831 if key in self.__fields:
1832 setattr(self, key, kwargs[key])
1833 del kwargs[key]
1834 if __debug__:
1836 self._complainaboutunusedargs(schedulefile,kwargs)
1837 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1838
1840
1841 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1842 'Writes this packet to the supplied buffer'
1843 self._bufferstartoffset=buf.getcurrentoffset()
1844 self.__field_numactiveitems.writetobuffer(buf)
1845 try: self.__field_events
1846 except:
1847 self.__field_events=LIST(**{'elementclass': scheduleevent})
1848 self.__field_events.writetobuffer(buf)
1849 self._bufferendoffset=buf.getcurrentoffset()
1850 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1851
1852
1853 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1854 'Reads this packet from the supplied buffer'
1855 self._bufferstartoffset=buf.getcurrentoffset()
1856 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1857 self.__field_numactiveitems=UINT(**{'sizeinbytes': 2})
1858 self.__field_numactiveitems.readfrombuffer(buf)
1859 self.__field_events=LIST(**{'elementclass': scheduleevent})
1860 self.__field_events.readfrombuffer(buf)
1861 self._bufferendoffset=buf.getcurrentoffset()
1862
1863
1864 def __getfield_numactiveitems(self):
1865 return self.__field_numactiveitems.getvalue()
1866
1867 def __setfield_numactiveitems(self, value):
1868 if isinstance(value,UINT):
1869 self.__field_numactiveitems=value
1870 else:
1871 self.__field_numactiveitems=UINT(value,**{'sizeinbytes': 2})
1872
1873 def __delfield_numactiveitems(self): del self.__field_numactiveitems
1874
1875 numactiveitems=property(__getfield_numactiveitems, __setfield_numactiveitems, __delfield_numactiveitems, None)
1876
1877 def __getfield_events(self):
1878 try: self.__field_events
1879 except:
1880 self.__field_events=LIST(**{'elementclass': scheduleevent})
1881 return self.__field_events.getvalue()
1882
1883 def __setfield_events(self, value):
1884 if isinstance(value,LIST):
1885 self.__field_events=value
1886 else:
1887 self.__field_events=LIST(value,**{'elementclass': scheduleevent})
1888
1889 def __delfield_events(self): del self.__field_events
1890
1891 events=property(__getfield_events, __setfield_events, __delfield_events, None)
1892
1893 def iscontainer(self):
1894 return True
1895
1896 def containerelements(self):
1897 yield ('numactiveitems', self.__field_numactiveitems, None)
1898 yield ('events', self.__field_events, None)
1899
1900
1901
1902
1903 class textmemo(BaseProtogenClass):
1904 __fields=['text']
1905
1906 def __init__(self, *args, **kwargs):
1907 dict={}
1908 dict.update(kwargs)
1910 super(textmemo,self).__init__(**dict)
1912 if self.__class__ is textmemo:
1913 self._update(args,dict)
1914
1915
1916 def getfields(self):
1917 return self.__fields
1918
1919
1920 def _update(self, args, kwargs):
1921 super(textmemo,self)._update(args,kwargs)
1922 keys=kwargs.keys()
1923 for key in keys:
1924 if key in self.__fields:
1925 setattr(self, key, kwargs[key])
1926 del kwargs[key]
1927 if __debug__:
1929 self._complainaboutunusedargs(textmemo,kwargs)
1930 if len(args):
1931 dict2={'sizeinbytes': 151, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False }
1932 dict2.update(kwargs)
1933 kwargs=dict2
1934 self.__field_text=USTRING(*args,**dict2)
1935
1937
1938 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1939 'Writes this packet to the supplied buffer'
1940 self._bufferstartoffset=buf.getcurrentoffset()
1941 self.__field_text.writetobuffer(buf)
1942 self._bufferendoffset=buf.getcurrentoffset()
1943 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1944
1945
1946 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1947 'Reads this packet from the supplied buffer'
1948 self._bufferstartoffset=buf.getcurrentoffset()
1949 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1950 self.__field_text=USTRING(**{'sizeinbytes': 151, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False })
1951 self.__field_text.readfrombuffer(buf)
1952 self._bufferendoffset=buf.getcurrentoffset()
1953
1954
1955 def __getfield_text(self):
1956 return self.__field_text.getvalue()
1957
1958 def __setfield_text(self, value):
1959 if isinstance(value,USTRING):
1960 self.__field_text=value
1961 else:
1962 self.__field_text=USTRING(value,**{'sizeinbytes': 151, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False })
1963
1964 def __delfield_text(self): del self.__field_text
1965
1966 text=property(__getfield_text, __setfield_text, __delfield_text, None)
1967
1968 def iscontainer(self):
1969 return True
1970
1971 def containerelements(self):
1972 yield ('text', self.__field_text, None)
1973
1974
1975
1976
1977 class textmemofile(BaseProtogenClass):
1978 __fields=['itemcount', 'items']
1979
1980 def __init__(self, *args, **kwargs):
1981 dict={}
1982 dict.update(kwargs)
1984 super(textmemofile,self).__init__(**dict)
1986 if self.__class__ is textmemofile:
1987 self._update(args,dict)
1988
1989
1990 def getfields(self):
1991 return self.__fields
1992
1993
1994 def _update(self, args, kwargs):
1995 super(textmemofile,self)._update(args,kwargs)
1996 keys=kwargs.keys()
1997 for key in keys:
1998 if key in self.__fields:
1999 setattr(self, key, kwargs[key])
2000 del kwargs[key]
2001 if __debug__:
2003 self._complainaboutunusedargs(textmemofile,kwargs)
2004 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2005
2007
2008 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2009 'Writes this packet to the supplied buffer'
2010 self._bufferstartoffset=buf.getcurrentoffset()
2011 self.__field_itemcount.writetobuffer(buf)
2012 try: self.__field_items
2013 except:
2014 self.__field_items=LIST(**{ 'elementclass': textmemo })
2015 self.__field_items.writetobuffer(buf)
2016 self._bufferendoffset=buf.getcurrentoffset()
2017 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2018
2019
2020 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2021 'Reads this packet from the supplied buffer'
2022 self._bufferstartoffset=buf.getcurrentoffset()
2023 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2024 self.__field_itemcount=UINT(**{'sizeinbytes': 4})
2025 self.__field_itemcount.readfrombuffer(buf)
2026 self.__field_items=LIST(**{ 'elementclass': textmemo })
2027 self.__field_items.readfrombuffer(buf)
2028 self._bufferendoffset=buf.getcurrentoffset()
2029
2030
2031 def __getfield_itemcount(self):
2032 return self.__field_itemcount.getvalue()
2033
2034 def __setfield_itemcount(self, value):
2035 if isinstance(value,UINT):
2036 self.__field_itemcount=value
2037 else:
2038 self.__field_itemcount=UINT(value,**{'sizeinbytes': 4})
2039
2040 def __delfield_itemcount(self): del self.__field_itemcount
2041
2042 itemcount=property(__getfield_itemcount, __setfield_itemcount, __delfield_itemcount, None)
2043
2044 def __getfield_items(self):
2045 try: self.__field_items
2046 except:
2047 self.__field_items=LIST(**{ 'elementclass': textmemo })
2048 return self.__field_items.getvalue()
2049
2050 def __setfield_items(self, value):
2051 if isinstance(value,LIST):
2052 self.__field_items=value
2053 else:
2054 self.__field_items=LIST(value,**{ 'elementclass': textmemo })
2055
2056 def __delfield_items(self): del self.__field_items
2057
2058 items=property(__getfield_items, __setfield_items, __delfield_items, None)
2059
2060 def iscontainer(self):
2061 return True
2062
2063 def containerelements(self):
2064 yield ('itemcount', self.__field_itemcount, None)
2065 yield ('items', self.__field_items, None)
2066
2067
2068
2069
2070 class callentry(BaseProtogenClass):
2071 __fields=['GPStime', 'pad1', 'duration', 'number', 'name', 'pad2']
2072
2073 def __init__(self, *args, **kwargs):
2074 dict={}
2075 dict.update(kwargs)
2077 super(callentry,self).__init__(**dict)
2079 if self.__class__ is callentry:
2080 self._update(args,dict)
2081
2082
2083 def getfields(self):
2084 return self.__fields
2085
2086
2087 def _update(self, args, kwargs):
2088 super(callentry,self)._update(args,kwargs)
2089 keys=kwargs.keys()
2090 for key in keys:
2091 if key in self.__fields:
2092 setattr(self, key, kwargs[key])
2093 del kwargs[key]
2094 if __debug__:
2096 self._complainaboutunusedargs(callentry,kwargs)
2097 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2098
2100
2101 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2102 'Writes this packet to the supplied buffer'
2103 self._bufferstartoffset=buf.getcurrentoffset()
2104 self.__field_GPStime.writetobuffer(buf)
2105 self.__field_pad1.writetobuffer(buf)
2106 self.__field_duration.writetobuffer(buf)
2107 self.__field_number.writetobuffer(buf)
2108 self.__field_name.writetobuffer(buf)
2109 self.__field_pad2.writetobuffer(buf)
2110 self._bufferendoffset=buf.getcurrentoffset()
2111 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2112
2113
2114 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2115 'Reads this packet from the supplied buffer'
2116 self._bufferstartoffset=buf.getcurrentoffset()
2117 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2118 self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4})
2119 self.__field_GPStime.readfrombuffer(buf)
2120 self.__field_pad1=UNKNOWN(**{'sizeinbytes': 4})
2121 self.__field_pad1.readfrombuffer(buf)
2122 self.__field_duration=UINT(**{'sizeinbytes': 4})
2123 self.__field_duration.readfrombuffer(buf)
2124 self.__field_number=USTRING(**{'sizeinbytes': 49, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False })
2125 self.__field_number.readfrombuffer(buf)
2126 self.__field_name=USTRING(**{'sizeinbytes': 36, 'raiseonunterminatedread': False })
2127 self.__field_name.readfrombuffer(buf)
2128 self.__field_pad2=UNKNOWN(**{'sizeinbytes': 8})
2129 self.__field_pad2.readfrombuffer(buf)
2130 self._bufferendoffset=buf.getcurrentoffset()
2131
2132
2133 def __getfield_GPStime(self):
2134 return self.__field_GPStime.getvalue()
2135
2136 def __setfield_GPStime(self, value):
2137 if isinstance(value,GPSDATE):
2138 self.__field_GPStime=value
2139 else:
2140 self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4})
2141
2142 def __delfield_GPStime(self): del self.__field_GPStime
2143
2144 GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None)
2145
2146 def __getfield_pad1(self):
2147 return self.__field_pad1.getvalue()
2148
2149 def __setfield_pad1(self, value):
2150 if isinstance(value,UNKNOWN):
2151 self.__field_pad1=value
2152 else:
2153 self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 4})
2154
2155 def __delfield_pad1(self): del self.__field_pad1
2156
2157 pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None)
2158
2159 def __getfield_duration(self):
2160 return self.__field_duration.getvalue()
2161
2162 def __setfield_duration(self, value):
2163 if isinstance(value,UINT):
2164 self.__field_duration=value
2165 else:
2166 self.__field_duration=UINT(value,**{'sizeinbytes': 4})
2167
2168 def __delfield_duration(self): del self.__field_duration
2169
2170 duration=property(__getfield_duration, __setfield_duration, __delfield_duration, None)
2171
2172 def __getfield_number(self):
2173 return self.__field_number.getvalue()
2174
2175 def __setfield_number(self, value):
2176 if isinstance(value,USTRING):
2177 self.__field_number=value
2178 else:
2179 self.__field_number=USTRING(value,**{'sizeinbytes': 49, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False })
2180
2181 def __delfield_number(self): del self.__field_number
2182
2183 number=property(__getfield_number, __setfield_number, __delfield_number, None)
2184
2185 def __getfield_name(self):
2186 return self.__field_name.getvalue()
2187
2188 def __setfield_name(self, value):
2189 if isinstance(value,USTRING):
2190 self.__field_name=value
2191 else:
2192 self.__field_name=USTRING(value,**{'sizeinbytes': 36, 'raiseonunterminatedread': False })
2193
2194 def __delfield_name(self): del self.__field_name
2195
2196 name=property(__getfield_name, __setfield_name, __delfield_name, None)
2197
2198 def __getfield_pad2(self):
2199 return self.__field_pad2.getvalue()
2200
2201 def __setfield_pad2(self, value):
2202 if isinstance(value,UNKNOWN):
2203 self.__field_pad2=value
2204 else:
2205 self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 8})
2206
2207 def __delfield_pad2(self): del self.__field_pad2
2208
2209 pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None)
2210
2211 def iscontainer(self):
2212 return True
2213
2214 def containerelements(self):
2215 yield ('GPStime', self.__field_GPStime, None)
2216 yield ('pad1', self.__field_pad1, None)
2217 yield ('duration', self.__field_duration, None)
2218 yield ('number', self.__field_number, None)
2219 yield ('name', self.__field_name, None)
2220 yield ('pad2', self.__field_pad2, None)
2221
2222
2223
2224
2225 class callhistory(BaseProtogenClass):
2226 __fields=['numcalls', 'pad1', 'calls']
2227
2228 def __init__(self, *args, **kwargs):
2229 dict={}
2230 dict.update(kwargs)
2232 super(callhistory,self).__init__(**dict)
2234 if self.__class__ is callhistory:
2235 self._update(args,dict)
2236
2237
2238 def getfields(self):
2239 return self.__fields
2240
2241
2242 def _update(self, args, kwargs):
2243 super(callhistory,self)._update(args,kwargs)
2244 keys=kwargs.keys()
2245 for key in keys:
2246 if key in self.__fields:
2247 setattr(self, key, kwargs[key])
2248 del kwargs[key]
2249 if __debug__:
2251 self._complainaboutunusedargs(callhistory,kwargs)
2252 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2253
2255
2256 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2257 'Writes this packet to the supplied buffer'
2258 self._bufferstartoffset=buf.getcurrentoffset()
2259 self.__field_numcalls.writetobuffer(buf)
2260 self.__field_pad1.writetobuffer(buf)
2261 try: self.__field_calls
2262 except:
2263 self.__field_calls=LIST(**{ 'elementclass': callentry })
2264 self.__field_calls.writetobuffer(buf)
2265 self._bufferendoffset=buf.getcurrentoffset()
2266 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2267
2268
2269 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2270 'Reads this packet from the supplied buffer'
2271 self._bufferstartoffset=buf.getcurrentoffset()
2272 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2273 self.__field_numcalls=UINT(**{'sizeinbytes': 4})
2274 self.__field_numcalls.readfrombuffer(buf)
2275 self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1})
2276 self.__field_pad1.readfrombuffer(buf)
2277 self.__field_calls=LIST(**{ 'elementclass': callentry })
2278 self.__field_calls.readfrombuffer(buf)
2279 self._bufferendoffset=buf.getcurrentoffset()
2280
2281
2282 def __getfield_numcalls(self):
2283 return self.__field_numcalls.getvalue()
2284
2285 def __setfield_numcalls(self, value):
2286 if isinstance(value,UINT):
2287 self.__field_numcalls=value
2288 else:
2289 self.__field_numcalls=UINT(value,**{'sizeinbytes': 4})
2290
2291 def __delfield_numcalls(self): del self.__field_numcalls
2292
2293 numcalls=property(__getfield_numcalls, __setfield_numcalls, __delfield_numcalls, None)
2294
2295 def __getfield_pad1(self):
2296 return self.__field_pad1.getvalue()
2297
2298 def __setfield_pad1(self, value):
2299 if isinstance(value,UNKNOWN):
2300 self.__field_pad1=value
2301 else:
2302 self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 1})
2303
2304 def __delfield_pad1(self): del self.__field_pad1
2305
2306 pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None)
2307
2308 def __getfield_calls(self):
2309 try: self.__field_calls
2310 except:
2311 self.__field_calls=LIST(**{ 'elementclass': callentry })
2312 return self.__field_calls.getvalue()
2313
2314 def __setfield_calls(self, value):
2315 if isinstance(value,LIST):
2316 self.__field_calls=value
2317 else:
2318 self.__field_calls=LIST(value,**{ 'elementclass': callentry })
2319
2320 def __delfield_calls(self): del self.__field_calls
2321
2322 calls=property(__getfield_calls, __setfield_calls, __delfield_calls, None)
2323
2324 def iscontainer(self):
2325 return True
2326
2327 def containerelements(self):
2328 yield ('numcalls', self.__field_numcalls, None)
2329 yield ('pad1', self.__field_pad1, None)
2330 yield ('calls', self.__field_calls, None)
2331
2332
2333
2334
2335 class msg_record(BaseProtogenClass):
2336 __fields=['binary', 'unknown3', 'unknown4', 'unknown6', 'length', 'msg']
2337
2338 def __init__(self, *args, **kwargs):
2339 dict={}
2340 dict.update(kwargs)
2342 super(msg_record,self).__init__(**dict)
2344 if self.__class__ is msg_record:
2345 self._update(args,dict)
2346
2347
2348 def getfields(self):
2349 return self.__fields
2350
2351
2352 def _update(self, args, kwargs):
2353 super(msg_record,self)._update(args,kwargs)
2354 keys=kwargs.keys()
2355 for key in keys:
2356 if key in self.__fields:
2357 setattr(self, key, kwargs[key])
2358 del kwargs[key]
2359 if __debug__:
2361 self._complainaboutunusedargs(msg_record,kwargs)
2362 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2363
2365
2366 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2367 'Writes this packet to the supplied buffer'
2368 self._bufferstartoffset=buf.getcurrentoffset()
2369 self.__field_binary.writetobuffer(buf)
2370 self.__field_unknown3.writetobuffer(buf)
2371 self.__field_unknown4.writetobuffer(buf)
2372 self.__field_unknown6.writetobuffer(buf)
2373 self.__field_length.writetobuffer(buf)
2374 try: self.__field_msg
2375 except:
2376 self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx7000_216, 'length': 220})
2377 self.__field_msg.writetobuffer(buf)
2378 self._bufferendoffset=buf.getcurrentoffset()
2379 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2380
2381
2382 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2383 'Reads this packet from the supplied buffer'
2384 self._bufferstartoffset=buf.getcurrentoffset()
2385 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2386 self.__field_binary=UINT(**{'sizeinbytes': 1})
2387 self.__field_binary.readfrombuffer(buf)
2388 self.__field_unknown3=UINT(**{'sizeinbytes': 1})
2389 self.__field_unknown3.readfrombuffer(buf)
2390 self.__field_unknown4=UINT(**{'sizeinbytes': 1})
2391 self.__field_unknown4.readfrombuffer(buf)
2392 self.__field_unknown6=UINT(**{'sizeinbytes': 1})
2393 self.__field_unknown6.readfrombuffer(buf)
2394 self.__field_length=UINT(**{'sizeinbytes': 1})
2395 self.__field_length.readfrombuffer(buf)
2396 self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx7000_216, 'length': 220})
2397 self.__field_msg.readfrombuffer(buf)
2398 self._bufferendoffset=buf.getcurrentoffset()
2399
2400
2401 def __getfield_binary(self):
2402 return self.__field_binary.getvalue()
2403
2404 def __setfield_binary(self, value):
2405 if isinstance(value,UINT):
2406 self.__field_binary=value
2407 else:
2408 self.__field_binary=UINT(value,**{'sizeinbytes': 1})
2409
2410 def __delfield_binary(self): del self.__field_binary
2411
2412 binary=property(__getfield_binary, __setfield_binary, __delfield_binary, None)
2413
2414 def __getfield_unknown3(self):
2415 return self.__field_unknown3.getvalue()
2416
2417 def __setfield_unknown3(self, value):
2418 if isinstance(value,UINT):
2419 self.__field_unknown3=value
2420 else:
2421 self.__field_unknown3=UINT(value,**{'sizeinbytes': 1})
2422
2423 def __delfield_unknown3(self): del self.__field_unknown3
2424
2425 unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None)
2426
2427 def __getfield_unknown4(self):
2428 return self.__field_unknown4.getvalue()
2429
2430 def __setfield_unknown4(self, value):
2431 if isinstance(value,UINT):
2432 self.__field_unknown4=value
2433 else:
2434 self.__field_unknown4=UINT(value,**{'sizeinbytes': 1})
2435
2436 def __delfield_unknown4(self): del self.__field_unknown4
2437
2438 unknown4=property(__getfield_unknown4, __setfield_unknown4, __delfield_unknown4, None)
2439
2440 def __getfield_unknown6(self):
2441 return self.__field_unknown6.getvalue()
2442
2443 def __setfield_unknown6(self, value):
2444 if isinstance(value,UINT):
2445 self.__field_unknown6=value
2446 else:
2447 self.__field_unknown6=UINT(value,**{'sizeinbytes': 1})
2448
2449 def __delfield_unknown6(self): del self.__field_unknown6
2450
2451 unknown6=property(__getfield_unknown6, __setfield_unknown6, __delfield_unknown6, None)
2452
2453 def __getfield_length(self):
2454 return self.__field_length.getvalue()
2455
2456 def __setfield_length(self, value):
2457 if isinstance(value,UINT):
2458 self.__field_length=value
2459 else:
2460 self.__field_length=UINT(value,**{'sizeinbytes': 1})
2461
2462 def __delfield_length(self): del self.__field_length
2463
2464 length=property(__getfield_length, __setfield_length, __delfield_length, None)
2465
2466 def __getfield_msg(self):
2467 try: self.__field_msg
2468 except:
2469 self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx7000_216, 'length': 220})
2470 return self.__field_msg.getvalue()
2471
2472 def __setfield_msg(self, value):
2473 if isinstance(value,LIST):
2474 self.__field_msg=value
2475 else:
2476 self.__field_msg=LIST(value,**{'elementclass': _gen_p_lgvx7000_216, 'length': 220})
2477
2478 def __delfield_msg(self): del self.__field_msg
2479
2480 msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None)
2481
2482 def iscontainer(self):
2483 return True
2484
2485 def containerelements(self):
2486 yield ('binary', self.__field_binary, None)
2487 yield ('unknown3', self.__field_unknown3, None)
2488 yield ('unknown4', self.__field_unknown4, None)
2489 yield ('unknown6', self.__field_unknown6, None)
2490 yield ('length', self.__field_length, None)
2491 yield ('msg', self.__field_msg, None)
2492
2493
2494
2495
2496 class _gen_p_lgvx7000_216(BaseProtogenClass):
2497 'Anonymous inner class'
2498 __fields=['byte']
2499
2500 def __init__(self, *args, **kwargs):
2501 dict={}
2502 dict.update(kwargs)
2504 super(_gen_p_lgvx7000_216,self).__init__(**dict)
2506 if self.__class__ is _gen_p_lgvx7000_216:
2507 self._update(args,dict)
2508
2509
2510 def getfields(self):
2511 return self.__fields
2512
2513
2514 def _update(self, args, kwargs):
2515 super(_gen_p_lgvx7000_216,self)._update(args,kwargs)
2516 keys=kwargs.keys()
2517 for key in keys:
2518 if key in self.__fields:
2519 setattr(self, key, kwargs[key])
2520 del kwargs[key]
2521 if __debug__:
2523 self._complainaboutunusedargs(_gen_p_lgvx7000_216,kwargs)
2524 if len(args):
2525 dict2={'sizeinbytes': 1}
2526 dict2.update(kwargs)
2527 kwargs=dict2
2528 self.__field_byte=UINT(*args,**dict2)
2529
2531
2532 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2533 'Writes this packet to the supplied buffer'
2534 self._bufferstartoffset=buf.getcurrentoffset()
2535 self.__field_byte.writetobuffer(buf)
2536 self._bufferendoffset=buf.getcurrentoffset()
2537 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2538
2539
2540 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2541 'Reads this packet from the supplied buffer'
2542 self._bufferstartoffset=buf.getcurrentoffset()
2543 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2544 self.__field_byte=UINT(**{'sizeinbytes': 1})
2545 self.__field_byte.readfrombuffer(buf)
2546 self._bufferendoffset=buf.getcurrentoffset()
2547
2548
2549 def __getfield_byte(self):
2550 return self.__field_byte.getvalue()
2551
2552 def __setfield_byte(self, value):
2553 if isinstance(value,UINT):
2554 self.__field_byte=value
2555 else:
2556 self.__field_byte=UINT(value,**{'sizeinbytes': 1})
2557
2558 def __delfield_byte(self): del self.__field_byte
2559
2560 byte=property(__getfield_byte, __setfield_byte, __delfield_byte, "individual byte of message")
2561
2562 def iscontainer(self):
2563 return True
2564
2565 def containerelements(self):
2566 yield ('byte', self.__field_byte, "individual byte of message")
2567
2568
2569
2570
2571 class recipient_record(BaseProtogenClass):
2572 __fields=['number', 'status', 'timesent', 'timereceived', 'unknown2']
2573
2574 def __init__(self, *args, **kwargs):
2575 dict={}
2576 dict.update(kwargs)
2578 super(recipient_record,self).__init__(**dict)
2580 if self.__class__ is recipient_record:
2581 self._update(args,dict)
2582
2583
2584 def getfields(self):
2585 return self.__fields
2586
2587
2588 def _update(self, args, kwargs):
2589 super(recipient_record,self)._update(args,kwargs)
2590 keys=kwargs.keys()
2591 for key in keys:
2592 if key in self.__fields:
2593 setattr(self, key, kwargs[key])
2594 del kwargs[key]
2595 if __debug__:
2597 self._complainaboutunusedargs(recipient_record,kwargs)
2598 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2599
2601
2602 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2603 'Writes this packet to the supplied buffer'
2604 self._bufferstartoffset=buf.getcurrentoffset()
2605 self.__field_number.writetobuffer(buf)
2606 self.__field_status.writetobuffer(buf)
2607 self.__field_timesent.writetobuffer(buf)
2608 self.__field_timereceived.writetobuffer(buf)
2609 self.__field_unknown2.writetobuffer(buf)
2610 self._bufferendoffset=buf.getcurrentoffset()
2611 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2612
2613
2614 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2615 'Reads this packet from the supplied buffer'
2616 self._bufferstartoffset=buf.getcurrentoffset()
2617 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2618 self.__field_number=USTRING(**{'sizeinbytes': 49})
2619 self.__field_number.readfrombuffer(buf)
2620 self.__field_status=UINT(**{'sizeinbytes': 2})
2621 self.__field_status.readfrombuffer(buf)
2622 self.__field_timesent=LGCALDATE(**{'sizeinbytes': 4})
2623 self.__field_timesent.readfrombuffer(buf)
2624 self.__field_timereceived=LGCALDATE(**{'sizeinbytes': 4})
2625 self.__field_timereceived.readfrombuffer(buf)
2626 self.__field_unknown2=UNKNOWN(**{'sizeinbytes': 49})
2627 self.__field_unknown2.readfrombuffer(buf)
2628 self._bufferendoffset=buf.getcurrentoffset()
2629
2630
2631 def __getfield_number(self):
2632 return self.__field_number.getvalue()
2633
2634 def __setfield_number(self, value):
2635 if isinstance(value,USTRING):
2636 self.__field_number=value
2637 else:
2638 self.__field_number=USTRING(value,**{'sizeinbytes': 49})
2639
2640 def __delfield_number(self): del self.__field_number
2641
2642 number=property(__getfield_number, __setfield_number, __delfield_number, None)
2643
2644 def __getfield_status(self):
2645 return self.__field_status.getvalue()
2646
2647 def __setfield_status(self, value):
2648 if isinstance(value,UINT):
2649 self.__field_status=value
2650 else:
2651 self.__field_status=UINT(value,**{'sizeinbytes': 2})
2652
2653 def __delfield_status(self): del self.__field_status
2654
2655 status=property(__getfield_status, __setfield_status, __delfield_status, None)
2656
2657 def __getfield_timesent(self):
2658 return self.__field_timesent.getvalue()
2659
2660 def __setfield_timesent(self, value):
2661 if isinstance(value,LGCALDATE):
2662 self.__field_timesent=value
2663 else:
2664 self.__field_timesent=LGCALDATE(value,**{'sizeinbytes': 4})
2665
2666 def __delfield_timesent(self): del self.__field_timesent
2667
2668 timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None)
2669
2670 def __getfield_timereceived(self):
2671 return self.__field_timereceived.getvalue()
2672
2673 def __setfield_timereceived(self, value):
2674 if isinstance(value,LGCALDATE):
2675 self.__field_timereceived=value
2676 else:
2677 self.__field_timereceived=LGCALDATE(value,**{'sizeinbytes': 4})
2678
2679 def __delfield_timereceived(self): del self.__field_timereceived
2680
2681 timereceived=property(__getfield_timereceived, __setfield_timereceived, __delfield_timereceived, None)
2682
2683 def __getfield_unknown2(self):
2684 return self.__field_unknown2.getvalue()
2685
2686 def __setfield_unknown2(self, value):
2687 if isinstance(value,UNKNOWN):
2688 self.__field_unknown2=value
2689 else:
2690 self.__field_unknown2=UNKNOWN(value,**{'sizeinbytes': 49})
2691
2692 def __delfield_unknown2(self): del self.__field_unknown2
2693
2694 unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None)
2695
2696 def iscontainer(self):
2697 return True
2698
2699 def containerelements(self):
2700 yield ('number', self.__field_number, None)
2701 yield ('status', self.__field_status, None)
2702 yield ('timesent', self.__field_timesent, None)
2703 yield ('timereceived', self.__field_timereceived, None)
2704 yield ('unknown2', self.__field_unknown2, None)
2705
2706
2707
2708
2709 class sms_saved(BaseProtogenClass):
2710 __fields=['outboxmsg', 'pad', 'outbox', 'inbox']
2711
2712 def __init__(self, *args, **kwargs):
2713 dict={}
2714 dict.update(kwargs)
2716 super(sms_saved,self).__init__(**dict)
2718 if self.__class__ is sms_saved:
2719 self._update(args,dict)
2720
2721
2722 def getfields(self):
2723 return self.__fields
2724
2725
2726 def _update(self, args, kwargs):
2727 super(sms_saved,self)._update(args,kwargs)
2728 keys=kwargs.keys()
2729 for key in keys:
2730 if key in self.__fields:
2731 setattr(self, key, kwargs[key])
2732 del kwargs[key]
2733 if __debug__:
2735 self._complainaboutunusedargs(sms_saved,kwargs)
2736 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2737
2739
2740 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2741 'Writes this packet to the supplied buffer'
2742 self._bufferstartoffset=buf.getcurrentoffset()
2743 self.__field_outboxmsg.writetobuffer(buf)
2744 self.__field_pad.writetobuffer(buf)
2745 if self.outboxmsg:
2746 self.__field_outbox.writetobuffer(buf)
2747 if not self.outboxmsg:
2748 self.__field_inbox.writetobuffer(buf)
2749 self._bufferendoffset=buf.getcurrentoffset()
2750 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2751
2752
2753 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2754 'Reads this packet from the supplied buffer'
2755 self._bufferstartoffset=buf.getcurrentoffset()
2756 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2757 self.__field_outboxmsg=UINT(**{'sizeinbytes': 4})
2758 self.__field_outboxmsg.readfrombuffer(buf)
2759 self.__field_pad=UNKNOWN(**{'sizeinbytes': 4})
2760 self.__field_pad.readfrombuffer(buf)
2761 if self.outboxmsg:
2762 self.__field_outbox=sms_out()
2763 self.__field_outbox.readfrombuffer(buf)
2764 if not self.outboxmsg:
2765 self.__field_inbox=sms_in()
2766 self.__field_inbox.readfrombuffer(buf)
2767 self._bufferendoffset=buf.getcurrentoffset()
2768
2769
2770 def __getfield_outboxmsg(self):
2771 return self.__field_outboxmsg.getvalue()
2772
2773 def __setfield_outboxmsg(self, value):
2774 if isinstance(value,UINT):
2775 self.__field_outboxmsg=value
2776 else:
2777 self.__field_outboxmsg=UINT(value,**{'sizeinbytes': 4})
2778
2779 def __delfield_outboxmsg(self): del self.__field_outboxmsg
2780
2781 outboxmsg=property(__getfield_outboxmsg, __setfield_outboxmsg, __delfield_outboxmsg, None)
2782
2783 def __getfield_pad(self):
2784 return self.__field_pad.getvalue()
2785
2786 def __setfield_pad(self, value):
2787 if isinstance(value,UNKNOWN):
2788 self.__field_pad=value
2789 else:
2790 self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 4})
2791
2792 def __delfield_pad(self): del self.__field_pad
2793
2794 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
2795
2796 def __getfield_outbox(self):
2797 return self.__field_outbox.getvalue()
2798
2799 def __setfield_outbox(self, value):
2800 if isinstance(value,sms_out):
2801 self.__field_outbox=value
2802 else:
2803 self.__field_outbox=sms_out(value,)
2804
2805 def __delfield_outbox(self): del self.__field_outbox
2806
2807 outbox=property(__getfield_outbox, __setfield_outbox, __delfield_outbox, None)
2808
2809 def __getfield_inbox(self):
2810 return self.__field_inbox.getvalue()
2811
2812 def __setfield_inbox(self, value):
2813 if isinstance(value,sms_in):
2814 self.__field_inbox=value
2815 else:
2816 self.__field_inbox=sms_in(value,)
2817
2818 def __delfield_inbox(self): del self.__field_inbox
2819
2820 inbox=property(__getfield_inbox, __setfield_inbox, __delfield_inbox, None)
2821
2822 def iscontainer(self):
2823 return True
2824
2825 def containerelements(self):
2826 yield ('outboxmsg', self.__field_outboxmsg, None)
2827 yield ('pad', self.__field_pad, None)
2828 if self.outboxmsg:
2829 yield ('outbox', self.__field_outbox, None)
2830 if not self.outboxmsg:
2831 yield ('inbox', self.__field_inbox, None)
2832
2833
2834
2835
2836 class sms_out(BaseProtogenClass):
2837 __fields=['index', 'locked', 'unknown2', 'timesent', 'unknown2', 'subject', 'unknown4', 'num_msg_elements', 'messages', 'unknown1', 'priority', 'unknown5', 'callback', 'recipients', 'pad']
2838
2839 def __init__(self, *args, **kwargs):
2840 dict={}
2841 dict.update(kwargs)
2843 super(sms_out,self).__init__(**dict)
2845 if self.__class__ is sms_out:
2846 self._update(args,dict)
2847
2848
2849 def getfields(self):
2850 return self.__fields
2851
2852
2853 def _update(self, args, kwargs):
2854 super(sms_out,self)._update(args,kwargs)
2855 keys=kwargs.keys()
2856 for key in keys:
2857 if key in self.__fields:
2858 setattr(self, key, kwargs[key])
2859 del kwargs[key]
2860 if __debug__:
2862 self._complainaboutunusedargs(sms_out,kwargs)
2863 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2864
2866
2867 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2868 'Writes this packet to the supplied buffer'
2869 self._bufferstartoffset=buf.getcurrentoffset()
2870 self.__field_index.writetobuffer(buf)
2871 self.__field_locked.writetobuffer(buf)
2872 self.__field_unknown2.writetobuffer(buf)
2873 self.__field_timesent.writetobuffer(buf)
2874 self.__field_unknown2.writetobuffer(buf)
2875 self.__field_subject.writetobuffer(buf)
2876 self.__field_unknown4.writetobuffer(buf)
2877 self.__field_num_msg_elements.writetobuffer(buf)
2878 try: self.__field_messages
2879 except:
2880 self.__field_messages=LIST(**{'elementclass': msg_record, 'length': 7})
2881 self.__field_messages.writetobuffer(buf)
2882 self.__field_unknown1.writetobuffer(buf)
2883 self.__field_priority.writetobuffer(buf)
2884 self.__field_unknown5.writetobuffer(buf)
2885 self.__field_callback.writetobuffer(buf)
2886 try: self.__field_recipients
2887 except:
2888 self.__field_recipients=LIST(**{'elementclass': recipient_record,'length': 9})
2889 self.__field_recipients.writetobuffer(buf)
2890 self.__field_pad.writetobuffer(buf)
2891 self._bufferendoffset=buf.getcurrentoffset()
2892 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2893
2894
2895 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2896 'Reads this packet from the supplied buffer'
2897 self._bufferstartoffset=buf.getcurrentoffset()
2898 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2899 self.__field_index=UINT(**{'sizeinbytes': 4})
2900 self.__field_index.readfrombuffer(buf)
2901 self.__field_locked=UINT(**{'sizeinbytes': 1})
2902 self.__field_locked.readfrombuffer(buf)
2903 self.__field_unknown2=UNKNOWN(**{'sizeinbytes': 1})
2904 self.__field_unknown2.readfrombuffer(buf)
2905 self.__field_timesent=LGCALDATE(**{'sizeinbytes': 4})
2906 self.__field_timesent.readfrombuffer(buf)
2907 self.__field_unknown2=UNKNOWN(**{'sizeinbytes': 6})
2908 self.__field_unknown2.readfrombuffer(buf)
2909 self.__field_subject=USTRING(**{'sizeinbytes': 21, 'encoding': PHONE_ENCODING})
2910 self.__field_subject.readfrombuffer(buf)
2911 self.__field_unknown4=UNKNOWN(**{'sizeinbytes': 1})
2912 self.__field_unknown4.readfrombuffer(buf)
2913 self.__field_num_msg_elements=UINT(**{'sizeinbytes': 2})
2914 self.__field_num_msg_elements.readfrombuffer(buf)
2915 self.__field_messages=LIST(**{'elementclass': msg_record, 'length': 7})
2916 self.__field_messages.readfrombuffer(buf)
2917 self.__field_unknown1=UNKNOWN(**{'sizeinbytes': 14})
2918 self.__field_unknown1.readfrombuffer(buf)
2919 self.__field_priority=UINT(**{'sizeinbytes': 1})
2920 self.__field_priority.readfrombuffer(buf)
2921 self.__field_unknown5=UNKNOWN(**{'sizeinbytes': 1})
2922 self.__field_unknown5.readfrombuffer(buf)
2923 self.__field_callback=USTRING(**{'sizeinbytes': 35})
2924 self.__field_callback.readfrombuffer(buf)
2925 self.__field_recipients=LIST(**{'elementclass': recipient_record,'length': 9})
2926 self.__field_recipients.readfrombuffer(buf)
2927 self.__field_pad=UNKNOWN()
2928 self.__field_pad.readfrombuffer(buf)
2929 self._bufferendoffset=buf.getcurrentoffset()
2930
2931
2932 def __getfield_index(self):
2933 return self.__field_index.getvalue()
2934
2935 def __setfield_index(self, value):
2936 if isinstance(value,UINT):
2937 self.__field_index=value
2938 else:
2939 self.__field_index=UINT(value,**{'sizeinbytes': 4})
2940
2941 def __delfield_index(self): del self.__field_index
2942
2943 index=property(__getfield_index, __setfield_index, __delfield_index, None)
2944
2945 def __getfield_locked(self):
2946 return self.__field_locked.getvalue()
2947
2948 def __setfield_locked(self, value):
2949 if isinstance(value,UINT):
2950 self.__field_locked=value
2951 else:
2952 self.__field_locked=UINT(value,**{'sizeinbytes': 1})
2953
2954 def __delfield_locked(self): del self.__field_locked
2955
2956 locked=property(__getfield_locked, __setfield_locked, __delfield_locked, None)
2957
2958 def __getfield_unknown2(self):
2959 return self.__field_unknown2.getvalue()
2960
2961 def __setfield_unknown2(self, value):
2962 if isinstance(value,UNKNOWN):
2963 self.__field_unknown2=value
2964 else:
2965 self.__field_unknown2=UNKNOWN(value,**{'sizeinbytes': 1})
2966
2967 def __delfield_unknown2(self): del self.__field_unknown2
2968
2969 unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None)
2970
2971 def __getfield_timesent(self):
2972 return self.__field_timesent.getvalue()
2973
2974 def __setfield_timesent(self, value):
2975 if isinstance(value,LGCALDATE):
2976 self.__field_timesent=value
2977 else:
2978 self.__field_timesent=LGCALDATE(value,**{'sizeinbytes': 4})
2979
2980 def __delfield_timesent(self): del self.__field_timesent
2981
2982 timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None)
2983
2984 def __getfield_unknown2(self):
2985 return self.__field_unknown2.getvalue()
2986
2987 def __setfield_unknown2(self, value):
2988 if isinstance(value,UNKNOWN):
2989 self.__field_unknown2=value
2990 else:
2991 self.__field_unknown2=UNKNOWN(value,**{'sizeinbytes': 6})
2992
2993 def __delfield_unknown2(self): del self.__field_unknown2
2994
2995 unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None)
2996
2997 def __getfield_subject(self):
2998 return self.__field_subject.getvalue()
2999
3000 def __setfield_subject(self, value):
3001 if isinstance(value,USTRING):
3002 self.__field_subject=value
3003 else:
3004 self.__field_subject=USTRING(value,**{'sizeinbytes': 21, 'encoding': PHONE_ENCODING})
3005
3006 def __delfield_subject(self): del self.__field_subject
3007
3008 subject=property(__getfield_subject, __setfield_subject, __delfield_subject, None)
3009
3010 def __getfield_unknown4(self):
3011 return self.__field_unknown4.getvalue()
3012
3013 def __setfield_unknown4(self, value):
3014 if isinstance(value,UNKNOWN):
3015 self.__field_unknown4=value
3016 else:
3017 self.__field_unknown4=UNKNOWN(value,**{'sizeinbytes': 1})
3018
3019 def __delfield_unknown4(self): del self.__field_unknown4
3020
3021 unknown4=property(__getfield_unknown4, __setfield_unknown4, __delfield_unknown4, None)
3022
3023 def __getfield_num_msg_elements(self):
3024 return self.__field_num_msg_elements.getvalue()
3025
3026 def __setfield_num_msg_elements(self, value):
3027 if isinstance(value,UINT):
3028 self.__field_num_msg_elements=value
3029 else:
3030 self.__field_num_msg_elements=UINT(value,**{'sizeinbytes': 2})
3031
3032 def __delfield_num_msg_elements(self): del self.__field_num_msg_elements
3033
3034 num_msg_elements=property(__getfield_num_msg_elements, __setfield_num_msg_elements, __delfield_num_msg_elements, None)
3035
3036 def __getfield_messages(self):
3037 try: self.__field_messages
3038 except:
3039 self.__field_messages=LIST(**{'elementclass': msg_record, 'length': 7})
3040 return self.__field_messages.getvalue()
3041
3042 def __setfield_messages(self, value):
3043 if isinstance(value,LIST):
3044 self.__field_messages=value
3045 else:
30