PyXR

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



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

Generated by PyXR 0.9.4