PyXR

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

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