PyXR

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

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