PyXR

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

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