PyXR

c:\projects\bitpim\src \ phones \ p_lgpm225.py

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