PyXR

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



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

Generated by PyXR 0.9.4