PyXR

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

0001 # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE
0002 
0003 """Various descriptions of data specific to LG LX570 (Musiq)"""
0004 
0005 import re
0006 
0007 from prototypes import *
0008 from prototypeslg import *
0009 
0010 # Make all lg stuff available in this module as well
0011 from p_lgvx4400 import *
0012 
0013 
0014 # We use LSB for all integer like fields
0015 UINT=UINTlsb
0016 BOOL=BOOLlsb
0017 
0018 MEMOLENGTH=33
0019 NUMEMAILS=3
0020 NUMPHONENUMBERS=5
0021 NUMSPEEDDIALS=100
0022 FIRSTSPEEDDIAL=1
0023 LASTSPEEDDIAL=99
0024 SPEEDDIALINDEX=0
0025 
0026 numbertypetab=( 'cell', 'home', 'office', 'fax', 'pager' )
0027 
0028 PB_FILENAME='DB/SysDB/vCardSchema.vol'
0029 RT_MC_INDEX_FILENAME='setas/mcRingerIndex.map'
0030 RT_VM_INDEX_FILENAME='setas/voicememoRingerIndex.map'
0031 RT_MC_PATH='melodyComposer'
0032 RT_VM_PATH='VoiceDB/All/Memos'
0033 
0034 SMS_CANNED_MAX_ITEMS=40
0035 SMS_CANNED_MAX_LENGTH=101
0036 SMS_CANNED_FILENAME="sms/canned_msg.dat"
0037 SMS_PATTERNS={'Inbox': re.compile(r"^.*/inbox[0-9][0-9][0-9]\.dat$"),
0038              'Sent': re.compile(r"^.*/outbox[0-9][0-9][0-9]\.dat$"),
0039              }
0040 
0041 class indexentry(BaseProtogenClass):
0042     __fields=['index', 'mediatype', 'name']
0043 
0044     def __init__(self, *args, **kwargs):
0045         dict={}
0046         # What was supplied to this function
0047         dict.update(kwargs)
0048         # Parent constructor
0049         super(indexentry,self).__init__(**dict)
0050         if self.__class__ is indexentry:
0051             self._update(args,dict)
0052 
0053 
0054     def getfields(self):
0055         return self.__fields
0056 
0057 
0058     def _update(self, args, kwargs):
0059         super(indexentry,self)._update(args,kwargs)
0060         keys=kwargs.keys()
0061         for key in keys:
0062             if key in self.__fields:
0063                 setattr(self, key, kwargs[key])
0064                 del kwargs[key]
0065         # Were any unrecognized kwargs passed in?
0066         if __debug__:
0067             self._complainaboutunusedargs(indexentry,kwargs)
0068         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0069         # Make all P fields that haven't already been constructed
0070 
0071 
0072     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0073         'Writes this packet to the supplied buffer'
0074         self._bufferstartoffset=buf.getcurrentoffset()
0075         self.__field_index.writetobuffer(buf)
0076         self.__field_mediatype.writetobuffer(buf)
0077         try: self.__field_name
0078         except:
0079             self.__field_name=USTRING(**{'sizeinbytes': 40, 'default': ""})
0080         self.__field_name.writetobuffer(buf)
0081         self._bufferendoffset=buf.getcurrentoffset()
0082         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0083 
0084 
0085     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0086         'Reads this packet from the supplied buffer'
0087         self._bufferstartoffset=buf.getcurrentoffset()
0088         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0089         self.__field_index=UINT(**{'sizeinbytes': 1})
0090         self.__field_index.readfrombuffer(buf)
0091         self.__field_mediatype=UINT(**{'sizeinbytes': 1})
0092         self.__field_mediatype.readfrombuffer(buf)
0093         self.__field_name=USTRING(**{'sizeinbytes': 40, 'default': ""})
0094         self.__field_name.readfrombuffer(buf)
0095         self._bufferendoffset=buf.getcurrentoffset()
0096 
0097 
0098     def __getfield_index(self):
0099         return self.__field_index.getvalue()
0100 
0101     def __setfield_index(self, value):
0102         if isinstance(value,UINT):
0103             self.__field_index=value
0104         else:
0105             self.__field_index=UINT(value,**{'sizeinbytes': 1})
0106 
0107     def __delfield_index(self): del self.__field_index
0108 
0109     index=property(__getfield_index, __setfield_index, __delfield_index, None)
0110 
0111     def __getfield_mediatype(self):
0112         return self.__field_mediatype.getvalue()
0113 
0114     def __setfield_mediatype(self, value):
0115         if isinstance(value,UINT):
0116             self.__field_mediatype=value
0117         else:
0118             self.__field_mediatype=UINT(value,**{'sizeinbytes': 1})
0119 
0120     def __delfield_mediatype(self): del self.__field_mediatype
0121 
0122     mediatype=property(__getfield_mediatype, __setfield_mediatype, __delfield_mediatype, None)
0123 
0124     def __getfield_name(self):
0125         try: self.__field_name
0126         except:
0127             self.__field_name=USTRING(**{'sizeinbytes': 40, 'default': ""})
0128         return self.__field_name.getvalue()
0129 
0130     def __setfield_name(self, value):
0131         if isinstance(value,USTRING):
0132             self.__field_name=value
0133         else:
0134             self.__field_name=USTRING(value,**{'sizeinbytes': 40, 'default': ""})
0135 
0136     def __delfield_name(self): del self.__field_name
0137 
0138     name=property(__getfield_name, __setfield_name, __delfield_name, None)
0139 
0140     def iscontainer(self):
0141         return True
0142 
0143     def containerelements(self):
0144         yield ('index', self.__field_index, None)
0145         yield ('mediatype', self.__field_mediatype, None)
0146         yield ('name', self.__field_name, None)
0147 
0148 
0149 
0150 
0151 class indexfile(BaseProtogenClass):
0152     "Used for tracking wallpaper and ringtones"
0153     __fields=['numactiveitems', 'items']
0154 
0155     def __init__(self, *args, **kwargs):
0156         dict={}
0157         # What was supplied to this function
0158         dict.update(kwargs)
0159         # Parent constructor
0160         super(indexfile,self).__init__(**dict)
0161         if self.__class__ is indexfile:
0162             self._update(args,dict)
0163 
0164 
0165     def getfields(self):
0166         return self.__fields
0167 
0168 
0169     def _update(self, args, kwargs):
0170         super(indexfile,self)._update(args,kwargs)
0171         keys=kwargs.keys()
0172         for key in keys:
0173             if key in self.__fields:
0174                 setattr(self, key, kwargs[key])
0175                 del kwargs[key]
0176         # Were any unrecognized kwargs passed in?
0177         if __debug__:
0178             self._complainaboutunusedargs(indexfile,kwargs)
0179         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0180         # Make all P fields that haven't already been constructed
0181 
0182 
0183     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0184         'Writes this packet to the supplied buffer'
0185         self._bufferstartoffset=buf.getcurrentoffset()
0186         self.__field_numactiveitems.writetobuffer(buf)
0187         try: self.__field_items
0188         except:
0189             self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True})
0190         self.__field_items.writetobuffer(buf)
0191         self._bufferendoffset=buf.getcurrentoffset()
0192         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0193 
0194 
0195     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0196         'Reads this packet from the supplied buffer'
0197         self._bufferstartoffset=buf.getcurrentoffset()
0198         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0199         self.__field_numactiveitems=UINT(**{'sizeinbytes': 2})
0200         self.__field_numactiveitems.readfrombuffer(buf)
0201         self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True})
0202         self.__field_items.readfrombuffer(buf)
0203         self._bufferendoffset=buf.getcurrentoffset()
0204 
0205 
0206     def __getfield_numactiveitems(self):
0207         return self.__field_numactiveitems.getvalue()
0208 
0209     def __setfield_numactiveitems(self, value):
0210         if isinstance(value,UINT):
0211             self.__field_numactiveitems=value
0212         else:
0213             self.__field_numactiveitems=UINT(value,**{'sizeinbytes': 2})
0214 
0215     def __delfield_numactiveitems(self): del self.__field_numactiveitems
0216 
0217     numactiveitems=property(__getfield_numactiveitems, __setfield_numactiveitems, __delfield_numactiveitems, None)
0218 
0219     def __getfield_items(self):
0220         try: self.__field_items
0221         except:
0222             self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True})
0223         return self.__field_items.getvalue()
0224 
0225     def __setfield_items(self, value):
0226         if isinstance(value,LIST):
0227             self.__field_items=value
0228         else:
0229             self.__field_items=LIST(value,**{'elementclass': indexentry, 'createdefault': True})
0230 
0231     def __delfield_items(self): del self.__field_items
0232 
0233     items=property(__getfield_items, __setfield_items, __delfield_items, None)
0234 
0235     def iscontainer(self):
0236         return True
0237 
0238     def containerelements(self):
0239         yield ('numactiveitems', self.__field_numactiveitems, None)
0240         yield ('items', self.__field_items, None)
0241 
0242 
0243 
0244 
0245 class pbreadentryresponse(BaseProtogenClass):
0246     "Results of reading one entry"
0247     __fields=['header', 'entry']
0248 
0249     def __init__(self, *args, **kwargs):
0250         dict={}
0251         # What was supplied to this function
0252         dict.update(kwargs)
0253         # Parent constructor
0254         super(pbreadentryresponse,self).__init__(**dict)
0255         if self.__class__ is pbreadentryresponse:
0256             self._update(args,dict)
0257 
0258 
0259     def getfields(self):
0260         return self.__fields
0261 
0262 
0263     def _update(self, args, kwargs):
0264         super(pbreadentryresponse,self)._update(args,kwargs)
0265         keys=kwargs.keys()
0266         for key in keys:
0267             if key in self.__fields:
0268                 setattr(self, key, kwargs[key])
0269                 del kwargs[key]
0270         # Were any unrecognized kwargs passed in?
0271         if __debug__:
0272             self._complainaboutunusedargs(pbreadentryresponse,kwargs)
0273         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0274         # Make all P fields that haven't already been constructed
0275 
0276 
0277     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0278         'Writes this packet to the supplied buffer'
0279         self._bufferstartoffset=buf.getcurrentoffset()
0280         self.__field_header.writetobuffer(buf)
0281         self.__field_entry.writetobuffer(buf)
0282         self._bufferendoffset=buf.getcurrentoffset()
0283         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0284 
0285 
0286     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0287         'Reads this packet from the supplied buffer'
0288         self._bufferstartoffset=buf.getcurrentoffset()
0289         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0290         self.__field_header=pbheader()
0291         self.__field_header.readfrombuffer(buf)
0292         self.__field_entry=pbentry()
0293         self.__field_entry.readfrombuffer(buf)
0294         self._bufferendoffset=buf.getcurrentoffset()
0295 
0296 
0297     def __getfield_header(self):
0298         return self.__field_header.getvalue()
0299 
0300     def __setfield_header(self, value):
0301         if isinstance(value,pbheader):
0302             self.__field_header=value
0303         else:
0304             self.__field_header=pbheader(value,)
0305 
0306     def __delfield_header(self): del self.__field_header
0307 
0308     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0309 
0310     def __getfield_entry(self):
0311         return self.__field_entry.getvalue()
0312 
0313     def __setfield_entry(self, value):
0314         if isinstance(value,pbentry):
0315             self.__field_entry=value
0316         else:
0317             self.__field_entry=pbentry(value,)
0318 
0319     def __delfield_entry(self): del self.__field_entry
0320 
0321     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
0322 
0323     def iscontainer(self):
0324         return True
0325 
0326     def containerelements(self):
0327         yield ('header', self.__field_header, None)
0328         yield ('entry', self.__field_entry, None)
0329 
0330 
0331 
0332 
0333 class pbupdateentryrequest(BaseProtogenClass):
0334     __fields=['header', 'entry']
0335 
0336     def __init__(self, *args, **kwargs):
0337         dict={}
0338         # What was supplied to this function
0339         dict.update(kwargs)
0340         # Parent constructor
0341         super(pbupdateentryrequest,self).__init__(**dict)
0342         if self.__class__ is pbupdateentryrequest:
0343             self._update(args,dict)
0344 
0345 
0346     def getfields(self):
0347         return self.__fields
0348 
0349 
0350     def _update(self, args, kwargs):
0351         super(pbupdateentryrequest,self)._update(args,kwargs)
0352         keys=kwargs.keys()
0353         for key in keys:
0354             if key in self.__fields:
0355                 setattr(self, key, kwargs[key])
0356                 del kwargs[key]
0357         # Were any unrecognized kwargs passed in?
0358         if __debug__:
0359             self._complainaboutunusedargs(pbupdateentryrequest,kwargs)
0360         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0361         # Make all P fields that haven't already been constructed
0362 
0363 
0364     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0365         'Writes this packet to the supplied buffer'
0366         self._bufferstartoffset=buf.getcurrentoffset()
0367         try: self.__field_header
0368         except:
0369             self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01})
0370         self.__field_header.writetobuffer(buf)
0371         self.__field_entry.writetobuffer(buf)
0372         self._bufferendoffset=buf.getcurrentoffset()
0373         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0374 
0375 
0376     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0377         'Reads this packet from the supplied buffer'
0378         self._bufferstartoffset=buf.getcurrentoffset()
0379         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0380         self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01})
0381         self.__field_header.readfrombuffer(buf)
0382         self.__field_entry=pbentry()
0383         self.__field_entry.readfrombuffer(buf)
0384         self._bufferendoffset=buf.getcurrentoffset()
0385 
0386 
0387     def __getfield_header(self):
0388         try: self.__field_header
0389         except:
0390             self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01})
0391         return self.__field_header.getvalue()
0392 
0393     def __setfield_header(self, value):
0394         if isinstance(value,pbheader):
0395             self.__field_header=value
0396         else:
0397             self.__field_header=pbheader(value,**{'command': 0x04, 'flag': 0x01})
0398 
0399     def __delfield_header(self): del self.__field_header
0400 
0401     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0402 
0403     def __getfield_entry(self):
0404         return self.__field_entry.getvalue()
0405 
0406     def __setfield_entry(self, value):
0407         if isinstance(value,pbentry):
0408             self.__field_entry=value
0409         else:
0410             self.__field_entry=pbentry(value,)
0411 
0412     def __delfield_entry(self): del self.__field_entry
0413 
0414     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
0415 
0416     def iscontainer(self):
0417         return True
0418 
0419     def containerelements(self):
0420         yield ('header', self.__field_header, None)
0421         yield ('entry', self.__field_entry, None)
0422 
0423 
0424 
0425 
0426 class pbappendentryrequest(BaseProtogenClass):
0427     __fields=['header', 'entry']
0428 
0429     def __init__(self, *args, **kwargs):
0430         dict={}
0431         # What was supplied to this function
0432         dict.update(kwargs)
0433         # Parent constructor
0434         super(pbappendentryrequest,self).__init__(**dict)
0435         if self.__class__ is pbappendentryrequest:
0436             self._update(args,dict)
0437 
0438 
0439     def getfields(self):
0440         return self.__fields
0441 
0442 
0443     def _update(self, args, kwargs):
0444         super(pbappendentryrequest,self)._update(args,kwargs)
0445         keys=kwargs.keys()
0446         for key in keys:
0447             if key in self.__fields:
0448                 setattr(self, key, kwargs[key])
0449                 del kwargs[key]
0450         # Were any unrecognized kwargs passed in?
0451         if __debug__:
0452             self._complainaboutunusedargs(pbappendentryrequest,kwargs)
0453         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0454         # Make all P fields that haven't already been constructed
0455 
0456 
0457     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0458         'Writes this packet to the supplied buffer'
0459         self._bufferstartoffset=buf.getcurrentoffset()
0460         try: self.__field_header
0461         except:
0462             self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01})
0463         self.__field_header.writetobuffer(buf)
0464         self.__field_entry.writetobuffer(buf)
0465         self._bufferendoffset=buf.getcurrentoffset()
0466         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0467 
0468 
0469     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0470         'Reads this packet from the supplied buffer'
0471         self._bufferstartoffset=buf.getcurrentoffset()
0472         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0473         self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01})
0474         self.__field_header.readfrombuffer(buf)
0475         self.__field_entry=pbentry()
0476         self.__field_entry.readfrombuffer(buf)
0477         self._bufferendoffset=buf.getcurrentoffset()
0478 
0479 
0480     def __getfield_header(self):
0481         try: self.__field_header
0482         except:
0483             self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01})
0484         return self.__field_header.getvalue()
0485 
0486     def __setfield_header(self, value):
0487         if isinstance(value,pbheader):
0488             self.__field_header=value
0489         else:
0490             self.__field_header=pbheader(value,**{'command': 0x03, 'flag': 0x01})
0491 
0492     def __delfield_header(self): del self.__field_header
0493 
0494     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0495 
0496     def __getfield_entry(self):
0497         return self.__field_entry.getvalue()
0498 
0499     def __setfield_entry(self, value):
0500         if isinstance(value,pbentry):
0501             self.__field_entry=value
0502         else:
0503             self.__field_entry=pbentry(value,)
0504 
0505     def __delfield_entry(self): del self.__field_entry
0506 
0507     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
0508 
0509     def iscontainer(self):
0510         return True
0511 
0512     def containerelements(self):
0513         yield ('header', self.__field_header, None)
0514         yield ('entry', self.__field_entry, None)
0515 
0516 
0517 
0518 
0519 class pbentry(BaseProtogenClass):
0520     __fields=['serial1', 'entrysize', 'serial2', 'entrynumber', 'name', 'group', 'dunno1', 'ringtone', 'dunno2', 'memo', 'emails', 'url', 'speeddials', 'numbertypes', 'numbers', 'dunno3', 'wallpaper']
0521 
0522     def __init__(self, *args, **kwargs):
0523         dict={}
0524         # What was supplied to this function
0525         dict.update(kwargs)
0526         # Parent constructor
0527         super(pbentry,self).__init__(**dict)
0528         if self.__class__ is pbentry:
0529             self._update(args,dict)
0530 
0531 
0532     def getfields(self):
0533         return self.__fields
0534 
0535 
0536     def _update(self, args, kwargs):
0537         super(pbentry,self)._update(args,kwargs)
0538         keys=kwargs.keys()
0539         for key in keys:
0540             if key in self.__fields:
0541                 setattr(self, key, kwargs[key])
0542                 del kwargs[key]
0543         # Were any unrecognized kwargs passed in?
0544         if __debug__:
0545             self._complainaboutunusedargs(pbentry,kwargs)
0546         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0547         # Make all P fields that haven't already been constructed
0548         try: self.__field_wallpaper
0549         except:
0550             self.__field_wallpaper=UINT(**{ 'default': 0 })
0551 
0552 
0553     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0554         'Writes this packet to the supplied buffer'
0555         self._bufferstartoffset=buf.getcurrentoffset()
0556         self.__field_serial1.writetobuffer(buf)
0557         try: self.__field_entrysize
0558         except:
0559             self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0x029E})
0560         self.__field_entrysize.writetobuffer(buf)
0561         self.__field_serial2.writetobuffer(buf)
0562         self.__field_entrynumber.writetobuffer(buf)
0563         self.__field_name.writetobuffer(buf)
0564         self.__field_group.writetobuffer(buf)
0565         try: self.__field_dunno1
0566         except:
0567             self.__field_dunno1=UINT(**{'sizeinbytes': 1,  'default': 0 })
0568         self.__field_dunno1.writetobuffer(buf)
0569         self.__field_ringtone.writetobuffer(buf)
0570         try: self.__field_dunno2
0571         except:
0572             self.__field_dunno2=UINT(**{'sizeinbytes': 2,  'default': 0 })
0573         self.__field_dunno2.writetobuffer(buf)
0574         self.__field_memo.writetobuffer(buf)
0575         try: self.__field_emails
0576         except:
0577             self.__field_emails=LIST(**{'elementclass': _gen_p_lglx570_100, 'length': NUMEMAILS})
0578         self.__field_emails.writetobuffer(buf)
0579         self.__field_url.writetobuffer(buf)
0580         try: self.__field_speeddials
0581         except:
0582             self.__field_speeddials=LIST(**{'elementclass': _gen_p_lglx570_103,  'length': NUMPHONENUMBERS })
0583         self.__field_speeddials.writetobuffer(buf)
0584         try: self.__field_numbertypes
0585         except:
0586             self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lglx570_105, 'length': NUMPHONENUMBERS})
0587         self.__field_numbertypes.writetobuffer(buf)
0588         try: self.__field_numbers
0589         except:
0590             self.__field_numbers=LIST(**{'elementclass': _gen_p_lglx570_107, 'length': NUMPHONENUMBERS})
0591         self.__field_numbers.writetobuffer(buf)
0592         try: self.__field_dunno3
0593         except:
0594             self.__field_dunno3=UINT(**{'sizeinbytes': 2,  'default': 0 })
0595         self.__field_dunno3.writetobuffer(buf)
0596         self._bufferendoffset=buf.getcurrentoffset()
0597         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0598 
0599 
0600     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0601         'Reads this packet from the supplied buffer'
0602         self._bufferstartoffset=buf.getcurrentoffset()
0603         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0604         self.__field_serial1=UINT(**{'sizeinbytes': 4})
0605         self.__field_serial1.readfrombuffer(buf)
0606         self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0x029E})
0607         self.__field_entrysize.readfrombuffer(buf)
0608         self.__field_serial2=UINT(**{'sizeinbytes': 4})
0609         self.__field_serial2.readfrombuffer(buf)
0610         self.__field_entrynumber=UINT(**{'sizeinbytes': 4})
0611         self.__field_entrynumber.readfrombuffer(buf)
0612         self.__field_name=USTRING(**{'sizeinbytes': 73, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
0613         self.__field_name.readfrombuffer(buf)
0614         self.__field_group=UINT(**{'sizeinbytes': 2})
0615         self.__field_group.readfrombuffer(buf)
0616         self.__field_dunno1=UINT(**{'sizeinbytes': 1,  'default': 0 })
0617         self.__field_dunno1.readfrombuffer(buf)
0618         self.__field_ringtone=UINT(**{'sizeinbytes': 2})
0619         self.__field_ringtone.readfrombuffer(buf)
0620         self.__field_dunno2=UINT(**{'sizeinbytes': 2,  'default': 0 })
0621         self.__field_dunno2.readfrombuffer(buf)
0622         self.__field_memo=USTRING(**{'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'sizeinbytes': MEMOLENGTH})
0623         self.__field_memo.readfrombuffer(buf)
0624         self.__field_emails=LIST(**{'elementclass': _gen_p_lglx570_100, 'length': NUMEMAILS})
0625         self.__field_emails.readfrombuffer(buf)
0626         self.__field_url=USTRING(**{'sizeinbytes': 73, 'raiseonunterminatedread': False})
0627         self.__field_url.readfrombuffer(buf)
0628         self.__field_speeddials=LIST(**{'elementclass': _gen_p_lglx570_103,  'length': NUMPHONENUMBERS })
0629         self.__field_speeddials.readfrombuffer(buf)
0630         self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lglx570_105, 'length': NUMPHONENUMBERS})
0631         self.__field_numbertypes.readfrombuffer(buf)
0632         self.__field_numbers=LIST(**{'elementclass': _gen_p_lglx570_107, 'length': NUMPHONENUMBERS})
0633         self.__field_numbers.readfrombuffer(buf)
0634         self.__field_dunno3=UINT(**{'sizeinbytes': 2,  'default': 0 })
0635         self.__field_dunno3.readfrombuffer(buf)
0636         self._bufferendoffset=buf.getcurrentoffset()
0637 
0638 
0639     def __getfield_serial1(self):
0640         return self.__field_serial1.getvalue()
0641 
0642     def __setfield_serial1(self, value):
0643         if isinstance(value,UINT):
0644             self.__field_serial1=value
0645         else:
0646             self.__field_serial1=UINT(value,**{'sizeinbytes': 4})
0647 
0648     def __delfield_serial1(self): del self.__field_serial1
0649 
0650     serial1=property(__getfield_serial1, __setfield_serial1, __delfield_serial1, None)
0651 
0652     def __getfield_entrysize(self):
0653         try: self.__field_entrysize
0654         except:
0655             self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0x029E})
0656         return self.__field_entrysize.getvalue()
0657 
0658     def __setfield_entrysize(self, value):
0659         if isinstance(value,UINT):
0660             self.__field_entrysize=value
0661         else:
0662             self.__field_entrysize=UINT(value,**{'sizeinbytes': 2, 'constant': 0x029E})
0663 
0664     def __delfield_entrysize(self): del self.__field_entrysize
0665 
0666     entrysize=property(__getfield_entrysize, __setfield_entrysize, __delfield_entrysize, None)
0667 
0668     def __getfield_serial2(self):
0669         return self.__field_serial2.getvalue()
0670 
0671     def __setfield_serial2(self, value):
0672         if isinstance(value,UINT):
0673             self.__field_serial2=value
0674         else:
0675             self.__field_serial2=UINT(value,**{'sizeinbytes': 4})
0676 
0677     def __delfield_serial2(self): del self.__field_serial2
0678 
0679     serial2=property(__getfield_serial2, __setfield_serial2, __delfield_serial2, None)
0680 
0681     def __getfield_entrynumber(self):
0682         return self.__field_entrynumber.getvalue()
0683 
0684     def __setfield_entrynumber(self, value):
0685         if isinstance(value,UINT):
0686             self.__field_entrynumber=value
0687         else:
0688             self.__field_entrynumber=UINT(value,**{'sizeinbytes': 4})
0689 
0690     def __delfield_entrynumber(self): del self.__field_entrynumber
0691 
0692     entrynumber=property(__getfield_entrynumber, __setfield_entrynumber, __delfield_entrynumber, None)
0693 
0694     def __getfield_name(self):
0695         return self.__field_name.getvalue()
0696 
0697     def __setfield_name(self, value):
0698         if isinstance(value,USTRING):
0699             self.__field_name=value
0700         else:
0701             self.__field_name=USTRING(value,**{'sizeinbytes': 73, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
0702 
0703     def __delfield_name(self): del self.__field_name
0704 
0705     name=property(__getfield_name, __setfield_name, __delfield_name, None)
0706 
0707     def __getfield_group(self):
0708         return self.__field_group.getvalue()
0709 
0710     def __setfield_group(self, value):
0711         if isinstance(value,UINT):
0712             self.__field_group=value
0713         else:
0714             self.__field_group=UINT(value,**{'sizeinbytes': 2})
0715 
0716     def __delfield_group(self): del self.__field_group
0717 
0718     group=property(__getfield_group, __setfield_group, __delfield_group, None)
0719 
0720     def __getfield_dunno1(self):
0721         try: self.__field_dunno1
0722         except:
0723             self.__field_dunno1=UINT(**{'sizeinbytes': 1,  'default': 0 })
0724         return self.__field_dunno1.getvalue()
0725 
0726     def __setfield_dunno1(self, value):
0727         if isinstance(value,UINT):
0728             self.__field_dunno1=value
0729         else:
0730             self.__field_dunno1=UINT(value,**{'sizeinbytes': 1,  'default': 0 })
0731 
0732     def __delfield_dunno1(self): del self.__field_dunno1
0733 
0734     dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None)
0735 
0736     def __getfield_ringtone(self):
0737         return self.__field_ringtone.getvalue()
0738 
0739     def __setfield_ringtone(self, value):
0740         if isinstance(value,UINT):
0741             self.__field_ringtone=value
0742         else:
0743             self.__field_ringtone=UINT(value,**{'sizeinbytes': 2})
0744 
0745     def __delfield_ringtone(self): del self.__field_ringtone
0746 
0747     ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None)
0748 
0749     def __getfield_dunno2(self):
0750         try: self.__field_dunno2
0751         except:
0752             self.__field_dunno2=UINT(**{'sizeinbytes': 2,  'default': 0 })
0753         return self.__field_dunno2.getvalue()
0754 
0755     def __setfield_dunno2(self, value):
0756         if isinstance(value,UINT):
0757             self.__field_dunno2=value
0758         else:
0759             self.__field_dunno2=UINT(value,**{'sizeinbytes': 2,  'default': 0 })
0760 
0761     def __delfield_dunno2(self): del self.__field_dunno2
0762 
0763     dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None)
0764 
0765     def __getfield_memo(self):
0766         return self.__field_memo.getvalue()
0767 
0768     def __setfield_memo(self, value):
0769         if isinstance(value,USTRING):
0770             self.__field_memo=value
0771         else:
0772             self.__field_memo=USTRING(value,**{'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'sizeinbytes': MEMOLENGTH})
0773 
0774     def __delfield_memo(self): del self.__field_memo
0775 
0776     memo=property(__getfield_memo, __setfield_memo, __delfield_memo, None)
0777 
0778     def __getfield_emails(self):
0779         try: self.__field_emails
0780         except:
0781             self.__field_emails=LIST(**{'elementclass': _gen_p_lglx570_100, 'length': NUMEMAILS})
0782         return self.__field_emails.getvalue()
0783 
0784     def __setfield_emails(self, value):
0785         if isinstance(value,LIST):
0786             self.__field_emails=value
0787         else:
0788             self.__field_emails=LIST(value,**{'elementclass': _gen_p_lglx570_100, 'length': NUMEMAILS})
0789 
0790     def __delfield_emails(self): del self.__field_emails
0791 
0792     emails=property(__getfield_emails, __setfield_emails, __delfield_emails, None)
0793 
0794     def __getfield_url(self):
0795         return self.__field_url.getvalue()
0796 
0797     def __setfield_url(self, value):
0798         if isinstance(value,USTRING):
0799             self.__field_url=value
0800         else:
0801             self.__field_url=USTRING(value,**{'sizeinbytes': 73, 'raiseonunterminatedread': False})
0802 
0803     def __delfield_url(self): del self.__field_url
0804 
0805     url=property(__getfield_url, __setfield_url, __delfield_url, None)
0806 
0807     def __getfield_speeddials(self):
0808         try: self.__field_speeddials
0809         except:
0810             self.__field_speeddials=LIST(**{'elementclass': _gen_p_lglx570_103,  'length': NUMPHONENUMBERS })
0811         return self.__field_speeddials.getvalue()
0812 
0813     def __setfield_speeddials(self, value):
0814         if isinstance(value,LIST):
0815             self.__field_speeddials=value
0816         else:
0817             self.__field_speeddials=LIST(value,**{'elementclass': _gen_p_lglx570_103,  'length': NUMPHONENUMBERS })
0818 
0819     def __delfield_speeddials(self): del self.__field_speeddials
0820 
0821     speeddials=property(__getfield_speeddials, __setfield_speeddials, __delfield_speeddials, None)
0822 
0823     def __getfield_numbertypes(self):
0824         try: self.__field_numbertypes
0825         except:
0826             self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lglx570_105, 'length': NUMPHONENUMBERS})
0827         return self.__field_numbertypes.getvalue()
0828 
0829     def __setfield_numbertypes(self, value):
0830         if isinstance(value,LIST):
0831             self.__field_numbertypes=value
0832         else:
0833             self.__field_numbertypes=LIST(value,**{'elementclass': _gen_p_lglx570_105, 'length': NUMPHONENUMBERS})
0834 
0835     def __delfield_numbertypes(self): del self.__field_numbertypes
0836 
0837     numbertypes=property(__getfield_numbertypes, __setfield_numbertypes, __delfield_numbertypes, None)
0838 
0839     def __getfield_numbers(self):
0840         try: self.__field_numbers
0841         except:
0842             self.__field_numbers=LIST(**{'elementclass': _gen_p_lglx570_107, 'length': NUMPHONENUMBERS})
0843         return self.__field_numbers.getvalue()
0844 
0845     def __setfield_numbers(self, value):
0846         if isinstance(value,LIST):
0847             self.__field_numbers=value
0848         else:
0849             self.__field_numbers=LIST(value,**{'elementclass': _gen_p_lglx570_107, 'length': NUMPHONENUMBERS})
0850 
0851     def __delfield_numbers(self): del self.__field_numbers
0852 
0853     numbers=property(__getfield_numbers, __setfield_numbers, __delfield_numbers, None)
0854 
0855     def __getfield_dunno3(self):
0856         try: self.__field_dunno3
0857         except:
0858             self.__field_dunno3=UINT(**{'sizeinbytes': 2,  'default': 0 })
0859         return self.__field_dunno3.getvalue()
0860 
0861     def __setfield_dunno3(self, value):
0862         if isinstance(value,UINT):
0863             self.__field_dunno3=value
0864         else:
0865             self.__field_dunno3=UINT(value,**{'sizeinbytes': 2,  'default': 0 })
0866 
0867     def __delfield_dunno3(self): del self.__field_dunno3
0868 
0869     dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None)
0870 
0871     def __getfield_wallpaper(self):
0872         try: self.__field_wallpaper
0873         except:
0874             self.__field_wallpaper=UINT(**{ 'default': 0 })
0875         return self.__field_wallpaper.getvalue()
0876 
0877     def __setfield_wallpaper(self, value):
0878         if isinstance(value,UINT):
0879             self.__field_wallpaper=value
0880         else:
0881             self.__field_wallpaper=UINT(value,**{ 'default': 0 })
0882 
0883     def __delfield_wallpaper(self): del self.__field_wallpaper
0884 
0885     wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None)
0886 
0887     def iscontainer(self):
0888         return True
0889 
0890     def containerelements(self):
0891         yield ('serial1', self.__field_serial1, None)
0892         yield ('entrysize', self.__field_entrysize, None)
0893         yield ('serial2', self.__field_serial2, None)
0894         yield ('entrynumber', self.__field_entrynumber, None)
0895         yield ('name', self.__field_name, None)
0896         yield ('group', self.__field_group, None)
0897         yield ('dunno1', self.__field_dunno1, None)
0898         yield ('ringtone', self.__field_ringtone, None)
0899         yield ('dunno2', self.__field_dunno2, None)
0900         yield ('memo', self.__field_memo, None)
0901         yield ('emails', self.__field_emails, None)
0902         yield ('url', self.__field_url, None)
0903         yield ('speeddials', self.__field_speeddials, None)
0904         yield ('numbertypes', self.__field_numbertypes, None)
0905         yield ('numbers', self.__field_numbers, None)
0906         yield ('dunno3', self.__field_dunno3, None)
0907         yield ('wallpaper', self.__field_wallpaper, None)
0908 
0909 
0910 
0911 
0912 class _gen_p_lglx570_100(BaseProtogenClass):
0913     'Anonymous inner class'
0914     __fields=['email']
0915 
0916     def __init__(self, *args, **kwargs):
0917         dict={}
0918         # What was supplied to this function
0919         dict.update(kwargs)
0920         # Parent constructor
0921         super(_gen_p_lglx570_100,self).__init__(**dict)
0922         if self.__class__ is _gen_p_lglx570_100:
0923             self._update(args,dict)
0924 
0925 
0926     def getfields(self):
0927         return self.__fields
0928 
0929 
0930     def _update(self, args, kwargs):
0931         super(_gen_p_lglx570_100,self)._update(args,kwargs)
0932         keys=kwargs.keys()
0933         for key in keys:
0934             if key in self.__fields:
0935                 setattr(self, key, kwargs[key])
0936                 del kwargs[key]
0937         # Were any unrecognized kwargs passed in?
0938         if __debug__:
0939             self._complainaboutunusedargs(_gen_p_lglx570_100,kwargs)
0940         if len(args):
0941             dict2={'sizeinbytes': 73, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}
0942             dict2.update(kwargs)
0943             kwargs=dict2
0944             self.__field_email=USTRING(*args,**dict2)
0945         # Make all P fields that haven't already been constructed
0946 
0947 
0948     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0949         'Writes this packet to the supplied buffer'
0950         self._bufferstartoffset=buf.getcurrentoffset()
0951         self.__field_email.writetobuffer(buf)
0952         self._bufferendoffset=buf.getcurrentoffset()
0953         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0954 
0955 
0956     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0957         'Reads this packet from the supplied buffer'
0958         self._bufferstartoffset=buf.getcurrentoffset()
0959         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0960         self.__field_email=USTRING(**{'sizeinbytes': 73, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
0961         self.__field_email.readfrombuffer(buf)
0962         self._bufferendoffset=buf.getcurrentoffset()
0963 
0964 
0965     def __getfield_email(self):
0966         return self.__field_email.getvalue()
0967 
0968     def __setfield_email(self, value):
0969         if isinstance(value,USTRING):
0970             self.__field_email=value
0971         else:
0972             self.__field_email=USTRING(value,**{'sizeinbytes': 73, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
0973 
0974     def __delfield_email(self): del self.__field_email
0975 
0976     email=property(__getfield_email, __setfield_email, __delfield_email, None)
0977 
0978     def iscontainer(self):
0979         return True
0980 
0981     def containerelements(self):
0982         yield ('email', self.__field_email, None)
0983 
0984 
0985 
0986 
0987 class _gen_p_lglx570_103(BaseProtogenClass):
0988     'Anonymous inner class'
0989     __fields=['speeddial']
0990 
0991     def __init__(self, *args, **kwargs):
0992         dict={}
0993         # What was supplied to this function
0994         dict.update(kwargs)
0995         # Parent constructor
0996         super(_gen_p_lglx570_103,self).__init__(**dict)
0997         if self.__class__ is _gen_p_lglx570_103:
0998             self._update(args,dict)
0999 
1000 
1001     def getfields(self):
1002         return self.__fields
1003 
1004 
1005     def _update(self, args, kwargs):
1006         super(_gen_p_lglx570_103,self)._update(args,kwargs)
1007         keys=kwargs.keys()
1008         for key in keys:
1009             if key in self.__fields:
1010                 setattr(self, key, kwargs[key])
1011                 del kwargs[key]
1012         # Were any unrecognized kwargs passed in?
1013         if __debug__:
1014             self._complainaboutunusedargs(_gen_p_lglx570_103,kwargs)
1015         if len(args):
1016             dict2={'sizeinbytes': 1,  'default': 0xff }
1017             dict2.update(kwargs)
1018             kwargs=dict2
1019             self.__field_speeddial=UINT(*args,**dict2)
1020         # Make all P fields that haven't already been constructed
1021 
1022 
1023     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1024         'Writes this packet to the supplied buffer'
1025         self._bufferstartoffset=buf.getcurrentoffset()
1026         try: self.__field_speeddial
1027         except:
1028             self.__field_speeddial=UINT(**{'sizeinbytes': 1,  'default': 0xff })
1029         self.__field_speeddial.writetobuffer(buf)
1030         self._bufferendoffset=buf.getcurrentoffset()
1031         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1032 
1033 
1034     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1035         'Reads this packet from the supplied buffer'
1036         self._bufferstartoffset=buf.getcurrentoffset()
1037         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1038         self.__field_speeddial=UINT(**{'sizeinbytes': 1,  'default': 0xff })
1039         self.__field_speeddial.readfrombuffer(buf)
1040         self._bufferendoffset=buf.getcurrentoffset()
1041 
1042 
1043     def __getfield_speeddial(self):
1044         try: self.__field_speeddial
1045         except:
1046             self.__field_speeddial=UINT(**{'sizeinbytes': 1,  'default': 0xff })
1047         return self.__field_speeddial.getvalue()
1048 
1049     def __setfield_speeddial(self, value):
1050         if isinstance(value,UINT):
1051             self.__field_speeddial=value
1052         else:
1053             self.__field_speeddial=UINT(value,**{'sizeinbytes': 1,  'default': 0xff })
1054 
1055     def __delfield_speeddial(self): del self.__field_speeddial
1056 
1057     speeddial=property(__getfield_speeddial, __setfield_speeddial, __delfield_speeddial, None)
1058 
1059     def iscontainer(self):
1060         return True
1061 
1062     def containerelements(self):
1063         yield ('speeddial', self.__field_speeddial, None)
1064 
1065 
1066 
1067 
1068 class _gen_p_lglx570_105(BaseProtogenClass):
1069     'Anonymous inner class'
1070     __fields=['numbertype']
1071 
1072     def __init__(self, *args, **kwargs):
1073         dict={}
1074         # What was supplied to this function
1075         dict.update(kwargs)
1076         # Parent constructor
1077         super(_gen_p_lglx570_105,self).__init__(**dict)
1078         if self.__class__ is _gen_p_lglx570_105:
1079             self._update(args,dict)
1080 
1081 
1082     def getfields(self):
1083         return self.__fields
1084 
1085 
1086     def _update(self, args, kwargs):
1087         super(_gen_p_lglx570_105,self)._update(args,kwargs)
1088         keys=kwargs.keys()
1089         for key in keys:
1090             if key in self.__fields:
1091                 setattr(self, key, kwargs[key])
1092                 del kwargs[key]
1093         # Were any unrecognized kwargs passed in?
1094         if __debug__:
1095             self._complainaboutunusedargs(_gen_p_lglx570_105,kwargs)
1096         if len(args):
1097             dict2={'sizeinbytes': 1}
1098             dict2.update(kwargs)
1099             kwargs=dict2
1100             self.__field_numbertype=UINT(*args,**dict2)
1101         # Make all P fields that haven't already been constructed
1102 
1103 
1104     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1105         'Writes this packet to the supplied buffer'
1106         self._bufferstartoffset=buf.getcurrentoffset()
1107         self.__field_numbertype.writetobuffer(buf)
1108         self._bufferendoffset=buf.getcurrentoffset()
1109         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1110 
1111 
1112     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1113         'Reads this packet from the supplied buffer'
1114         self._bufferstartoffset=buf.getcurrentoffset()
1115         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1116         self.__field_numbertype=UINT(**{'sizeinbytes': 1})
1117         self.__field_numbertype.readfrombuffer(buf)
1118         self._bufferendoffset=buf.getcurrentoffset()
1119 
1120 
1121     def __getfield_numbertype(self):
1122         return self.__field_numbertype.getvalue()
1123 
1124     def __setfield_numbertype(self, value):
1125         if isinstance(value,UINT):
1126             self.__field_numbertype=value
1127         else:
1128             self.__field_numbertype=UINT(value,**{'sizeinbytes': 1})
1129 
1130     def __delfield_numbertype(self): del self.__field_numbertype
1131 
1132     numbertype=property(__getfield_numbertype, __setfield_numbertype, __delfield_numbertype, None)
1133 
1134     def iscontainer(self):
1135         return True
1136 
1137     def containerelements(self):
1138         yield ('numbertype', self.__field_numbertype, None)
1139 
1140 
1141 
1142 
1143 class _gen_p_lglx570_107(BaseProtogenClass):
1144     'Anonymous inner class'
1145     __fields=['number']
1146 
1147     def __init__(self, *args, **kwargs):
1148         dict={}
1149         # What was supplied to this function
1150         dict.update(kwargs)
1151         # Parent constructor
1152         super(_gen_p_lglx570_107,self).__init__(**dict)
1153         if self.__class__ is _gen_p_lglx570_107:
1154             self._update(args,dict)
1155 
1156 
1157     def getfields(self):
1158         return self.__fields
1159 
1160 
1161     def _update(self, args, kwargs):
1162         super(_gen_p_lglx570_107,self)._update(args,kwargs)
1163         keys=kwargs.keys()
1164         for key in keys:
1165             if key in self.__fields:
1166                 setattr(self, key, kwargs[key])
1167                 del kwargs[key]
1168         # Were any unrecognized kwargs passed in?
1169         if __debug__:
1170             self._complainaboutunusedargs(_gen_p_lglx570_107,kwargs)
1171         if len(args):
1172             dict2={'sizeinbytes': 49, 'raiseonunterminatedread': False}
1173             dict2.update(kwargs)
1174             kwargs=dict2
1175             self.__field_number=USTRING(*args,**dict2)
1176         # Make all P fields that haven't already been constructed
1177 
1178 
1179     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1180         'Writes this packet to the supplied buffer'
1181         self._bufferstartoffset=buf.getcurrentoffset()
1182         self.__field_number.writetobuffer(buf)
1183         self._bufferendoffset=buf.getcurrentoffset()
1184         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1185 
1186 
1187     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1188         'Reads this packet from the supplied buffer'
1189         self._bufferstartoffset=buf.getcurrentoffset()
1190         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1191         self.__field_number=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
1192         self.__field_number.readfrombuffer(buf)
1193         self._bufferendoffset=buf.getcurrentoffset()
1194 
1195 
1196     def __getfield_number(self):
1197         return self.__field_number.getvalue()
1198 
1199     def __setfield_number(self, value):
1200         if isinstance(value,USTRING):
1201             self.__field_number=value
1202         else:
1203             self.__field_number=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
1204 
1205     def __delfield_number(self): del self.__field_number
1206 
1207     number=property(__getfield_number, __setfield_number, __delfield_number, None)
1208 
1209     def iscontainer(self):
1210         return True
1211 
1212     def containerelements(self):
1213         yield ('number', self.__field_number, None)
1214 
1215 
1216 
1217 
1218 class pbgroup(BaseProtogenClass):
1219     "A single group"
1220     __fields=['header', 'blocksize', 'dunno2', 'groupid', 'dunno3', 'name']
1221 
1222     def __init__(self, *args, **kwargs):
1223         dict={}
1224         # What was supplied to this function
1225         dict.update(kwargs)
1226         # Parent constructor
1227         super(pbgroup,self).__init__(**dict)
1228         if self.__class__ is pbgroup:
1229             self._update(args,dict)
1230 
1231 
1232     def getfields(self):
1233         return self.__fields
1234 
1235 
1236     def _update(self, args, kwargs):
1237         super(pbgroup,self)._update(args,kwargs)
1238         keys=kwargs.keys()
1239         for key in keys:
1240             if key in self.__fields:
1241                 setattr(self, key, kwargs[key])
1242                 del kwargs[key]
1243         # Were any unrecognized kwargs passed in?
1244         if __debug__:
1245             self._complainaboutunusedargs(pbgroup,kwargs)
1246         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1247         # Make all P fields that haven't already been constructed
1248 
1249 
1250     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1251         'Writes this packet to the supplied buffer'
1252         self._bufferstartoffset=buf.getcurrentoffset()
1253         self.__field_header.writetobuffer(buf)
1254         if self.valid:
1255             self.__field_blocksize.writetobuffer(buf)
1256             self.__field_dunno2.writetobuffer(buf)
1257             self.__field_groupid.writetobuffer(buf)
1258             self.__field_dunno3.writetobuffer(buf)
1259             self.__field_name.writetobuffer(buf)
1260         self._bufferendoffset=buf.getcurrentoffset()
1261         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1262 
1263 
1264     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1265         'Reads this packet from the supplied buffer'
1266         self._bufferstartoffset=buf.getcurrentoffset()
1267         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1268         self.__field_header=UINT(**{'sizeinbytes': 2})
1269         self.__field_header.readfrombuffer(buf)
1270         if self.valid:
1271             self.__field_blocksize=UINT(**{'sizeinbytes': 2})
1272             self.__field_blocksize.readfrombuffer(buf)
1273             self.__field_dunno2=DATA(**{'sizeinbytes': 9})
1274             self.__field_dunno2.readfrombuffer(buf)
1275             self.__field_groupid=UINT(**{'sizeinbytes': 2})
1276             self.__field_groupid.readfrombuffer(buf)
1277             self.__field_dunno3=DATA(**{'sizeinbytes': 16})
1278             self.__field_dunno3.readfrombuffer(buf)
1279             self.__field_name=USTRING(**{ 'encoding': PHONE_ENCODING,                    'sizeinbytes': self.namesize })
1280             self.__field_name.readfrombuffer(buf)
1281         self._bufferendoffset=buf.getcurrentoffset()
1282 
1283 
1284     def __getfield_header(self):
1285         return self.__field_header.getvalue()
1286 
1287     def __setfield_header(self, value):
1288         if isinstance(value,UINT):
1289             self.__field_header=value
1290         else:
1291             self.__field_header=UINT(value,**{'sizeinbytes': 2})
1292 
1293     def __delfield_header(self): del self.__field_header
1294 
1295     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1296 
1297     def __getfield_blocksize(self):
1298         return self.__field_blocksize.getvalue()
1299 
1300     def __setfield_blocksize(self, value):
1301         if isinstance(value,UINT):
1302             self.__field_blocksize=value
1303         else:
1304             self.__field_blocksize=UINT(value,**{'sizeinbytes': 2})
1305 
1306     def __delfield_blocksize(self): del self.__field_blocksize
1307 
1308     blocksize=property(__getfield_blocksize, __setfield_blocksize, __delfield_blocksize, None)
1309 
1310     def __getfield_dunno2(self):
1311         return self.__field_dunno2.getvalue()
1312 
1313     def __setfield_dunno2(self, value):
1314         if isinstance(value,DATA):
1315             self.__field_dunno2=value
1316         else:
1317             self.__field_dunno2=DATA(value,**{'sizeinbytes': 9})
1318 
1319     def __delfield_dunno2(self): del self.__field_dunno2
1320 
1321     dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None)
1322 
1323     def __getfield_groupid(self):
1324         return self.__field_groupid.getvalue()
1325 
1326     def __setfield_groupid(self, value):
1327         if isinstance(value,UINT):
1328             self.__field_groupid=value
1329         else:
1330             self.__field_groupid=UINT(value,**{'sizeinbytes': 2})
1331 
1332     def __delfield_groupid(self): del self.__field_groupid
1333 
1334     groupid=property(__getfield_groupid, __setfield_groupid, __delfield_groupid, None)
1335 
1336     def __getfield_dunno3(self):
1337         return self.__field_dunno3.getvalue()
1338 
1339     def __setfield_dunno3(self, value):
1340         if isinstance(value,DATA):
1341             self.__field_dunno3=value
1342         else:
1343             self.__field_dunno3=DATA(value,**{'sizeinbytes': 16})
1344 
1345     def __delfield_dunno3(self): del self.__field_dunno3
1346 
1347     dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None)
1348 
1349     def __getfield_name(self):
1350         return self.__field_name.getvalue()
1351 
1352     def __setfield_name(self, value):
1353         if isinstance(value,USTRING):
1354             self.__field_name=value
1355         else:
1356             self.__field_name=USTRING(value,**{ 'encoding': PHONE_ENCODING,                    'sizeinbytes': self.namesize })
1357 
1358     def __delfield_name(self): del self.__field_name
1359 
1360     name=property(__getfield_name, __setfield_name, __delfield_name, None)
1361 
1362     def iscontainer(self):
1363         return True
1364 
1365     def containerelements(self):
1366         yield ('header', self.__field_header, None)
1367         if self.valid:
1368             yield ('blocksize', self.__field_blocksize, None)
1369             yield ('dunno2', self.__field_dunno2, None)
1370             yield ('groupid', self.__field_groupid, None)
1371             yield ('dunno3', self.__field_dunno3, None)
1372             yield ('name', self.__field_name, None)
1373 
1374     def _getnamesize(self):
1375         # Return the length of the name, the size of data block must be on a
1376         # 4-byte word boundary
1377         _rem4=self.blocksize%4
1378         if _rem4:
1379             return self.blocksize+4-_rem4-27
1380         else:
1381             return self.blocksize-27
1382     namesize=property(fget=_getnamesize)
1383     def _getvalid(self):
1384         return self.header!=0xffff
1385     valid=property(fget=_getvalid)
1386 
1387 
1388 
1389 
1390 class pbgroups(BaseProtogenClass):
1391     "Phonebook groups"
1392     __fields=['groups']
1393 
1394     def __init__(self, *args, **kwargs):
1395         dict={}
1396         # What was supplied to this function
1397         dict.update(kwargs)
1398         # Parent constructor
1399         super(pbgroups,self).__init__(**dict)
1400         if self.__class__ is pbgroups:
1401             self._update(args,dict)
1402 
1403 
1404     def getfields(self):
1405         return self.__fields
1406 
1407 
1408     def _update(self, args, kwargs):
1409         super(pbgroups,self)._update(args,kwargs)
1410         keys=kwargs.keys()
1411         for key in keys:
1412             if key in self.__fields:
1413                 setattr(self, key, kwargs[key])
1414                 del kwargs[key]
1415         # Were any unrecognized kwargs passed in?
1416         if __debug__:
1417             self._complainaboutunusedargs(pbgroups,kwargs)
1418         if len(args):
1419             dict2={'elementclass': pbgroup}
1420             dict2.update(kwargs)
1421             kwargs=dict2
1422             self.__field_groups=LIST(*args,**dict2)
1423         # Make all P fields that haven't already been constructed
1424 
1425 
1426     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1427         'Writes this packet to the supplied buffer'
1428         self._bufferstartoffset=buf.getcurrentoffset()
1429         try: self.__field_groups
1430         except:
1431             self.__field_groups=LIST(**{'elementclass': pbgroup})
1432         self.__field_groups.writetobuffer(buf)
1433         self._bufferendoffset=buf.getcurrentoffset()
1434         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1435 
1436 
1437     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1438         'Reads this packet from the supplied buffer'
1439         self._bufferstartoffset=buf.getcurrentoffset()
1440         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1441         self.__field_groups=LIST(**{'elementclass': pbgroup})
1442         self.__field_groups.readfrombuffer(buf)
1443         self._bufferendoffset=buf.getcurrentoffset()
1444 
1445 
1446     def __getfield_groups(self):
1447         try: self.__field_groups
1448         except:
1449             self.__field_groups=LIST(**{'elementclass': pbgroup})
1450         return self.__field_groups.getvalue()
1451 
1452     def __setfield_groups(self, value):
1453         if isinstance(value,LIST):
1454             self.__field_groups=value
1455         else:
1456             self.__field_groups=LIST(value,**{'elementclass': pbgroup})
1457 
1458     def __delfield_groups(self): del self.__field_groups
1459 
1460     groups=property(__getfield_groups, __setfield_groups, __delfield_groups, None)
1461 
1462     def iscontainer(self):
1463         return True
1464 
1465     def containerelements(self):
1466         yield ('groups', self.__field_groups, None)
1467 
1468 
1469 
1470 
1471 class textmemo(BaseProtogenClass):
1472     __fields=['text']
1473 
1474     def __init__(self, *args, **kwargs):
1475         dict={}
1476         # What was supplied to this function
1477         dict.update(kwargs)
1478         # Parent constructor
1479         super(textmemo,self).__init__(**dict)
1480         if self.__class__ is textmemo:
1481             self._update(args,dict)
1482 
1483 
1484     def getfields(self):
1485         return self.__fields
1486 
1487 
1488     def _update(self, args, kwargs):
1489         super(textmemo,self)._update(args,kwargs)
1490         keys=kwargs.keys()
1491         for key in keys:
1492             if key in self.__fields:
1493                 setattr(self, key, kwargs[key])
1494                 del kwargs[key]
1495         # Were any unrecognized kwargs passed in?
1496         if __debug__:
1497             self._complainaboutunusedargs(textmemo,kwargs)
1498         if len(args):
1499             dict2={'sizeinbytes': 1001,  'encoding': PHONE_ENCODING,                   'raiseonunterminatedread': False,                   'raiseontruncate': False }
1500             dict2.update(kwargs)
1501             kwargs=dict2
1502             self.__field_text=USTRING(*args,**dict2)
1503         # Make all P fields that haven't already been constructed
1504 
1505 
1506     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1507         'Writes this packet to the supplied buffer'
1508         self._bufferstartoffset=buf.getcurrentoffset()
1509         self.__field_text.writetobuffer(buf)
1510         self._bufferendoffset=buf.getcurrentoffset()
1511         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1512 
1513 
1514     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1515         'Reads this packet from the supplied buffer'
1516         self._bufferstartoffset=buf.getcurrentoffset()
1517         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1518         self.__field_text=USTRING(**{'sizeinbytes': 1001,  'encoding': PHONE_ENCODING,                   'raiseonunterminatedread': False,                   'raiseontruncate': False })
1519         self.__field_text.readfrombuffer(buf)
1520         self._bufferendoffset=buf.getcurrentoffset()
1521 
1522 
1523     def __getfield_text(self):
1524         return self.__field_text.getvalue()
1525 
1526     def __setfield_text(self, value):
1527         if isinstance(value,USTRING):
1528             self.__field_text=value
1529         else:
1530             self.__field_text=USTRING(value,**{'sizeinbytes': 1001,  'encoding': PHONE_ENCODING,                   'raiseonunterminatedread': False,                   'raiseontruncate': False })
1531 
1532     def __delfield_text(self): del self.__field_text
1533 
1534     text=property(__getfield_text, __setfield_text, __delfield_text, None)
1535 
1536     def iscontainer(self):
1537         return True
1538 
1539     def containerelements(self):
1540         yield ('text', self.__field_text, None)
1541 
1542 
1543 
1544 
1545 class textmemofile(BaseProtogenClass):
1546     __fields=['itemcount', 'items']
1547 
1548     def __init__(self, *args, **kwargs):
1549         dict={}
1550         # What was supplied to this function
1551         dict.update(kwargs)
1552         # Parent constructor
1553         super(textmemofile,self).__init__(**dict)
1554         if self.__class__ is textmemofile:
1555             self._update(args,dict)
1556 
1557 
1558     def getfields(self):
1559         return self.__fields
1560 
1561 
1562     def _update(self, args, kwargs):
1563         super(textmemofile,self)._update(args,kwargs)
1564         keys=kwargs.keys()
1565         for key in keys:
1566             if key in self.__fields:
1567                 setattr(self, key, kwargs[key])
1568                 del kwargs[key]
1569         # Were any unrecognized kwargs passed in?
1570         if __debug__:
1571             self._complainaboutunusedargs(textmemofile,kwargs)
1572         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1573         # Make all P fields that haven't already been constructed
1574 
1575 
1576     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1577         'Writes this packet to the supplied buffer'
1578         self._bufferstartoffset=buf.getcurrentoffset()
1579         self.__field_itemcount.writetobuffer(buf)
1580         try: self.__field_items
1581         except:
1582             self.__field_items=LIST(**{ 'elementclass': textmemo })
1583         self.__field_items.writetobuffer(buf)
1584         self._bufferendoffset=buf.getcurrentoffset()
1585         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1586 
1587 
1588     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1589         'Reads this packet from the supplied buffer'
1590         self._bufferstartoffset=buf.getcurrentoffset()
1591         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1592         self.__field_itemcount=UINT(**{'sizeinbytes': 4})
1593         self.__field_itemcount.readfrombuffer(buf)
1594         self.__field_items=LIST(**{ 'elementclass': textmemo })
1595         self.__field_items.readfrombuffer(buf)
1596         self._bufferendoffset=buf.getcurrentoffset()
1597 
1598 
1599     def __getfield_itemcount(self):
1600         return self.__field_itemcount.getvalue()
1601 
1602     def __setfield_itemcount(self, value):
1603         if isinstance(value,UINT):
1604             self.__field_itemcount=value
1605         else:
1606             self.__field_itemcount=UINT(value,**{'sizeinbytes': 4})
1607 
1608     def __delfield_itemcount(self): del self.__field_itemcount
1609 
1610     itemcount=property(__getfield_itemcount, __setfield_itemcount, __delfield_itemcount, None)
1611 
1612     def __getfield_items(self):
1613         try: self.__field_items
1614         except:
1615             self.__field_items=LIST(**{ 'elementclass': textmemo })
1616         return self.__field_items.getvalue()
1617 
1618     def __setfield_items(self, value):
1619         if isinstance(value,LIST):
1620             self.__field_items=value
1621         else:
1622             self.__field_items=LIST(value,**{ 'elementclass': textmemo })
1623 
1624     def __delfield_items(self): del self.__field_items
1625 
1626     items=property(__getfield_items, __setfield_items, __delfield_items, None)
1627 
1628     def iscontainer(self):
1629         return True
1630 
1631     def containerelements(self):
1632         yield ('itemcount', self.__field_itemcount, None)
1633         yield ('items', self.__field_items, None)
1634 
1635 
1636 
1637 
1638 class recipient_record(BaseProtogenClass):
1639     __fields=['unknown1', 'name', 'number', 'status', 'unknown3', 'time', 'unknown2']
1640 
1641     def __init__(self, *args, **kwargs):
1642         dict={}
1643         # What was supplied to this function
1644         dict.update(kwargs)
1645         # Parent constructor
1646         super(recipient_record,self).__init__(**dict)
1647         if self.__class__ is recipient_record:
1648             self._update(args,dict)
1649 
1650 
1651     def getfields(self):
1652         return self.__fields
1653 
1654 
1655     def _update(self, args, kwargs):
1656         super(recipient_record,self)._update(args,kwargs)
1657         keys=kwargs.keys()
1658         for key in keys:
1659             if key in self.__fields:
1660                 setattr(self, key, kwargs[key])
1661                 del kwargs[key]
1662         # Were any unrecognized kwargs passed in?
1663         if __debug__:
1664             self._complainaboutunusedargs(recipient_record,kwargs)
1665         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1666         # Make all P fields that haven't already been constructed
1667 
1668 
1669     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1670         'Writes this packet to the supplied buffer'
1671         self._bufferstartoffset=buf.getcurrentoffset()
1672         self.__field_unknown1.writetobuffer(buf)
1673         self.__field_name.writetobuffer(buf)
1674         self.__field_number.writetobuffer(buf)
1675         self.__field_status.writetobuffer(buf)
1676         self.__field_unknown3.writetobuffer(buf)
1677         self.__field_time.writetobuffer(buf)
1678         self.__field_unknown2.writetobuffer(buf)
1679         self._bufferendoffset=buf.getcurrentoffset()
1680         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1681 
1682 
1683     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1684         'Reads this packet from the supplied buffer'
1685         self._bufferstartoffset=buf.getcurrentoffset()
1686         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1687         self.__field_unknown1=UINT(**{'sizeinbytes': 8})
1688         self.__field_unknown1.readfrombuffer(buf)
1689         self.__field_name=USTRING(**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
1690         self.__field_name.readfrombuffer(buf)
1691         self.__field_number=USTRING(**{'sizeinbytes': 73})
1692         self.__field_number.readfrombuffer(buf)
1693         self.__field_status=UINT(**{'sizeinbytes': 1})
1694         self.__field_status.readfrombuffer(buf)
1695         self.__field_unknown3=UINT(**{'sizeinbytes': 1})
1696         self.__field_unknown3.readfrombuffer(buf)
1697         self.__field_time=LGCALDATE(**{'sizeinbytes': 4})
1698         self.__field_time.readfrombuffer(buf)
1699         self.__field_unknown2=DATA(**{'sizeinbytes': 12})
1700         self.__field_unknown2.readfrombuffer(buf)
1701         self._bufferendoffset=buf.getcurrentoffset()
1702 
1703 
1704     def __getfield_unknown1(self):
1705         return self.__field_unknown1.getvalue()
1706 
1707     def __setfield_unknown1(self, value):
1708         if isinstance(value,UINT):
1709             self.__field_unknown1=value
1710         else:
1711             self.__field_unknown1=UINT(value,**{'sizeinbytes': 8})
1712 
1713     def __delfield_unknown1(self): del self.__field_unknown1
1714 
1715     unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None)
1716 
1717     def __getfield_name(self):
1718         return self.__field_name.getvalue()
1719 
1720     def __setfield_name(self, value):
1721         if isinstance(value,USTRING):
1722             self.__field_name=value
1723         else:
1724             self.__field_name=USTRING(value,**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
1725 
1726     def __delfield_name(self): del self.__field_name
1727 
1728     name=property(__getfield_name, __setfield_name, __delfield_name, None)
1729 
1730     def __getfield_number(self):
1731         return self.__field_number.getvalue()
1732 
1733     def __setfield_number(self, value):
1734         if isinstance(value,USTRING):
1735             self.__field_number=value
1736         else:
1737             self.__field_number=USTRING(value,**{'sizeinbytes': 73})
1738 
1739     def __delfield_number(self): del self.__field_number
1740 
1741     number=property(__getfield_number, __setfield_number, __delfield_number, None)
1742 
1743     def __getfield_status(self):
1744         return self.__field_status.getvalue()
1745 
1746     def __setfield_status(self, value):
1747         if isinstance(value,UINT):
1748             self.__field_status=value
1749         else:
1750             self.__field_status=UINT(value,**{'sizeinbytes': 1})
1751 
1752     def __delfield_status(self): del self.__field_status
1753 
1754     status=property(__getfield_status, __setfield_status, __delfield_status, None)
1755 
1756     def __getfield_unknown3(self):
1757         return self.__field_unknown3.getvalue()
1758 
1759     def __setfield_unknown3(self, value):
1760         if isinstance(value,UINT):
1761             self.__field_unknown3=value
1762         else:
1763             self.__field_unknown3=UINT(value,**{'sizeinbytes': 1})
1764 
1765     def __delfield_unknown3(self): del self.__field_unknown3
1766 
1767     unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None)
1768 
1769     def __getfield_time(self):
1770         return self.__field_time.getvalue()
1771 
1772     def __setfield_time(self, value):
1773         if isinstance(value,LGCALDATE):
1774             self.__field_time=value
1775         else:
1776             self.__field_time=LGCALDATE(value,**{'sizeinbytes': 4})
1777 
1778     def __delfield_time(self): del self.__field_time
1779 
1780     time=property(__getfield_time, __setfield_time, __delfield_time, None)
1781 
1782     def __getfield_unknown2(self):
1783         return self.__field_unknown2.getvalue()
1784 
1785     def __setfield_unknown2(self, value):
1786         if isinstance(value,DATA):
1787             self.__field_unknown2=value
1788         else:
1789             self.__field_unknown2=DATA(value,**{'sizeinbytes': 12})
1790 
1791     def __delfield_unknown2(self): del self.__field_unknown2
1792 
1793     unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None)
1794 
1795     def iscontainer(self):
1796         return True
1797 
1798     def containerelements(self):
1799         yield ('unknown1', self.__field_unknown1, None)
1800         yield ('name', self.__field_name, None)
1801         yield ('number', self.__field_number, None)
1802         yield ('status', self.__field_status, None)
1803         yield ('unknown3', self.__field_unknown3, None)
1804         yield ('time', self.__field_time, None)
1805         yield ('unknown2', self.__field_unknown2, None)
1806 
1807 
1808 
1809 
1810 class sms_out(BaseProtogenClass):
1811     __fields=['index', 'locked', 'unknown1', 'timesent', 'dunno1', 'saved', 'dunno2', 'priority', 'dunno2', 'callback', 'msg', 'recipients']
1812 
1813     def __init__(self, *args, **kwargs):
1814         dict={}
1815         # What was supplied to this function
1816         dict.update(kwargs)
1817         # Parent constructor
1818         super(sms_out,self).__init__(**dict)
1819         if self.__class__ is sms_out:
1820             self._update(args,dict)
1821 
1822 
1823     def getfields(self):
1824         return self.__fields
1825 
1826 
1827     def _update(self, args, kwargs):
1828         super(sms_out,self)._update(args,kwargs)
1829         keys=kwargs.keys()
1830         for key in keys:
1831             if key in self.__fields:
1832                 setattr(self, key, kwargs[key])
1833                 del kwargs[key]
1834         # Were any unrecognized kwargs passed in?
1835         if __debug__:
1836             self._complainaboutunusedargs(sms_out,kwargs)
1837         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1838         # Make all P fields that haven't already been constructed
1839 
1840 
1841     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1842         'Writes this packet to the supplied buffer'
1843         self._bufferstartoffset=buf.getcurrentoffset()
1844         self.__field_index.writetobuffer(buf)
1845         self.__field_locked.writetobuffer(buf)
1846         self.__field_unknown1.writetobuffer(buf)
1847         self.__field_timesent.writetobuffer(buf)
1848         self.__field_dunno1.writetobuffer(buf)
1849         self.__field_saved.writetobuffer(buf)
1850         self.__field_dunno2.writetobuffer(buf)
1851         self.__field_priority.writetobuffer(buf)
1852         self.__field_dunno2.writetobuffer(buf)
1853         self.__field_callback.writetobuffer(buf)
1854         self.__field_msg.writetobuffer(buf)
1855         try: self.__field_recipients
1856         except:
1857             self.__field_recipients=LIST(**{'elementclass': recipient_record, 'length': 10})
1858         self.__field_recipients.writetobuffer(buf)
1859         self._bufferendoffset=buf.getcurrentoffset()
1860         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1861 
1862 
1863     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1864         'Reads this packet from the supplied buffer'
1865         self._bufferstartoffset=buf.getcurrentoffset()
1866         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1867         self.__field_index=UINT(**{'sizeinbytes': 4})
1868         self.__field_index.readfrombuffer(buf)
1869         self.__field_locked=UINT(**{'sizeinbytes': 1})
1870         self.__field_locked.readfrombuffer(buf)
1871         self.__field_unknown1=UINT(**{'sizeinbytes': 3})
1872         self.__field_unknown1.readfrombuffer(buf)
1873         self.__field_timesent=LGCALDATE(**{'sizeinbytes': 4})
1874         self.__field_timesent.readfrombuffer(buf)
1875         self.__field_dunno1=DATA(**{'sizeinbytes': 2})
1876         self.__field_dunno1.readfrombuffer(buf)
1877         self.__field_saved=UINT(**{'sizeinbytes': 1})
1878         self.__field_saved.readfrombuffer(buf)
1879         self.__field_dunno2=DATA(**{'sizeinbytes': 5})
1880         self.__field_dunno2.readfrombuffer(buf)
1881         self.__field_priority=UINT(**{'sizeinbytes': 1})
1882         self.__field_priority.readfrombuffer(buf)
1883         self.__field_dunno2=DATA(**{'sizeinbytes': 15})
1884         self.__field_dunno2.readfrombuffer(buf)
1885         self.__field_callback=USTRING(**{'sizeinbytes': 20})
1886         self.__field_callback.readfrombuffer(buf)
1887         self.__field_msg=USTRING(**{'sizeinbytes': 160, 'encoding': PHONE_ENCODING})
1888         self.__field_msg.readfrombuffer(buf)
1889         self.__field_recipients=LIST(**{'elementclass': recipient_record, 'length': 10})
1890         self.__field_recipients.readfrombuffer(buf)
1891         self._bufferendoffset=buf.getcurrentoffset()
1892 
1893 
1894     def __getfield_index(self):
1895         return self.__field_index.getvalue()
1896 
1897     def __setfield_index(self, value):
1898         if isinstance(value,UINT):
1899             self.__field_index=value
1900         else:
1901             self.__field_index=UINT(value,**{'sizeinbytes': 4})
1902 
1903     def __delfield_index(self): del self.__field_index
1904 
1905     index=property(__getfield_index, __setfield_index, __delfield_index, None)
1906 
1907     def __getfield_locked(self):
1908         return self.__field_locked.getvalue()
1909 
1910     def __setfield_locked(self, value):
1911         if isinstance(value,UINT):
1912             self.__field_locked=value
1913         else:
1914             self.__field_locked=UINT(value,**{'sizeinbytes': 1})
1915 
1916     def __delfield_locked(self): del self.__field_locked
1917 
1918     locked=property(__getfield_locked, __setfield_locked, __delfield_locked, None)
1919 
1920     def __getfield_unknown1(self):
1921         return self.__field_unknown1.getvalue()
1922 
1923     def __setfield_unknown1(self, value):
1924         if isinstance(value,UINT):
1925             self.__field_unknown1=value
1926         else:
1927             self.__field_unknown1=UINT(value,**{'sizeinbytes': 3})
1928 
1929     def __delfield_unknown1(self): del self.__field_unknown1
1930 
1931     unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None)
1932 
1933     def __getfield_timesent(self):
1934         return self.__field_timesent.getvalue()
1935 
1936     def __setfield_timesent(self, value):
1937         if isinstance(value,LGCALDATE):
1938             self.__field_timesent=value
1939         else:
1940             self.__field_timesent=LGCALDATE(value,**{'sizeinbytes': 4})
1941 
1942     def __delfield_timesent(self): del self.__field_timesent
1943 
1944     timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None)
1945 
1946     def __getfield_dunno1(self):
1947         return self.__field_dunno1.getvalue()
1948 
1949     def __setfield_dunno1(self, value):
1950         if isinstance(value,DATA):
1951             self.__field_dunno1=value
1952         else:
1953             self.__field_dunno1=DATA(value,**{'sizeinbytes': 2})
1954 
1955     def __delfield_dunno1(self): del self.__field_dunno1
1956 
1957     dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None)
1958 
1959     def __getfield_saved(self):
1960         return self.__field_saved.getvalue()
1961 
1962     def __setfield_saved(self, value):
1963         if isinstance(value,UINT):
1964             self.__field_saved=value
1965         else:
1966             self.__field_saved=UINT(value,**{'sizeinbytes': 1})
1967 
1968     def __delfield_saved(self): del self.__field_saved
1969 
1970     saved=property(__getfield_saved, __setfield_saved, __delfield_saved, None)
1971 
1972     def __getfield_dunno2(self):
1973         return self.__field_dunno2.getvalue()
1974 
1975     def __setfield_dunno2(self, value):
1976         if isinstance(value,DATA):
1977             self.__field_dunno2=value
1978         else:
1979             self.__field_dunno2=DATA(value,**{'sizeinbytes': 5})
1980 
1981     def __delfield_dunno2(self): del self.__field_dunno2
1982 
1983     dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None)
1984 
1985     def __getfield_priority(self):
1986         return self.__field_priority.getvalue()
1987 
1988     def __setfield_priority(self, value):
1989         if isinstance(value,UINT):
1990             self.__field_priority=value
1991         else:
1992             self.__field_priority=UINT(value,**{'sizeinbytes': 1})
1993 
1994     def __delfield_priority(self): del self.__field_priority
1995 
1996     priority=property(__getfield_priority, __setfield_priority, __delfield_priority, "0=normal, 1=urgent")
1997 
1998     def __getfield_dunno2(self):
1999         return self.__field_dunno2.getvalue()
2000 
2001     def __setfield_dunno2(self, value):
2002         if isinstance(value,DATA):
2003             self.__field_dunno2=value
2004         else:
2005             self.__field_dunno2=DATA(value,**{'sizeinbytes': 15})
2006 
2007     def __delfield_dunno2(self): del self.__field_dunno2
2008 
2009     dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None)
2010 
2011     def __getfield_callback(self):
2012         return self.__field_callback.getvalue()
2013 
2014     def __setfield_callback(self, value):
2015         if isinstance(value,USTRING):
2016             self.__field_callback=value
2017         else:
2018             self.__field_callback=USTRING(value,**{'sizeinbytes': 20})
2019 
2020     def __delfield_callback(self): del self.__field_callback
2021 
2022     callback=property(__getfield_callback, __setfield_callback, __delfield_callback, None)
2023 
2024     def __getfield_msg(self):
2025         return self.__field_msg.getvalue()
2026 
2027     def __setfield_msg(self, value):
2028         if isinstance(value,USTRING):
2029             self.__field_msg=value
2030         else:
2031             self.__field_msg=USTRING(value,**{'sizeinbytes': 160, 'encoding': PHONE_ENCODING})
2032 
2033     def __delfield_msg(self): del self.__field_msg
2034 
2035     msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None)
2036 
2037     def __getfield_recipients(self):
2038         try: self.__field_recipients
2039         except:
2040             self.__field_recipients=LIST(**{'elementclass': recipient_record, 'length': 10})
2041         return self.__field_recipients.getvalue()
2042 
2043     def __setfield_recipients(self, value):
2044         if isinstance(value,LIST):
2045             self.__field_recipients=value
2046         else:
2047             self.__field_recipients=LIST(value,**{'elementclass': recipient_record, 'length': 10})
2048 
2049     def __delfield_recipients(self): del self.__field_recipients
2050 
2051     recipients=property(__getfield_recipients, __setfield_recipients, __delfield_recipients, None)
2052 
2053     def iscontainer(self):
2054         return True
2055 
2056     def containerelements(self):
2057         yield ('index', self.__field_index, None)
2058         yield ('locked', self.__field_locked, None)
2059         yield ('unknown1', self.__field_unknown1, None)
2060         yield ('timesent', self.__field_timesent, None)
2061         yield ('dunno1', self.__field_dunno1, None)
2062         yield ('saved', self.__field_saved, None)
2063         yield ('dunno2', self.__field_dunno2, None)
2064         yield ('priority', self.__field_priority, "0=normal, 1=urgent")
2065         yield ('dunno2', self.__field_dunno2, None)
2066         yield ('callback', self.__field_callback, None)
2067         yield ('msg', self.__field_msg, None)
2068         yield ('recipients', self.__field_recipients, None)
2069 
2070 
2071 
2072 
2073 class SMSINBOXMSGFRAGMENT(BaseProtogenClass):
2074     __fields=['msg']
2075 
2076     def __init__(self, *args, **kwargs):
2077         dict={}
2078         # What was supplied to this function
2079         dict.update(kwargs)
2080         # Parent constructor
2081         super(SMSINBOXMSGFRAGMENT,self).__init__(**dict)
2082         if self.__class__ is SMSINBOXMSGFRAGMENT:
2083             self._update(args,dict)
2084 
2085 
2086     def getfields(self):
2087         return self.__fields
2088 
2089 
2090     def _update(self, args, kwargs):
2091         super(SMSINBOXMSGFRAGMENT,self)._update(args,kwargs)
2092         keys=kwargs.keys()
2093         for key in keys:
2094             if key in self.__fields:
2095                 setattr(self, key, kwargs[key])
2096                 del kwargs[key]
2097         # Were any unrecognized kwargs passed in?
2098         if __debug__:
2099             self._complainaboutunusedargs(SMSINBOXMSGFRAGMENT,kwargs)
2100         if len(args):
2101             dict2={'elementclass': _gen_p_lglx570_191, 'length': 181}
2102             dict2.update(kwargs)
2103             kwargs=dict2
2104             self.__field_msg=LIST(*args,**dict2)
2105         # Make all P fields that haven't already been constructed
2106 
2107 
2108     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2109         'Writes this packet to the supplied buffer'
2110         self._bufferstartoffset=buf.getcurrentoffset()
2111         try: self.__field_msg
2112         except:
2113             self.__field_msg=LIST(**{'elementclass': _gen_p_lglx570_191, 'length': 181})
2114         self.__field_msg.writetobuffer(buf)
2115         self._bufferendoffset=buf.getcurrentoffset()
2116         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2117 
2118 
2119     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2120         'Reads this packet from the supplied buffer'
2121         self._bufferstartoffset=buf.getcurrentoffset()
2122         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2123         self.__field_msg=LIST(**{'elementclass': _gen_p_lglx570_191, 'length': 181})
2124         self.__field_msg.readfrombuffer(buf)
2125         self._bufferendoffset=buf.getcurrentoffset()
2126 
2127 
2128     def __getfield_msg(self):
2129         try: self.__field_msg
2130         except:
2131             self.__field_msg=LIST(**{'elementclass': _gen_p_lglx570_191, 'length': 181})
2132         return self.__field_msg.getvalue()
2133 
2134     def __setfield_msg(self, value):
2135         if isinstance(value,LIST):
2136             self.__field_msg=value
2137         else:
2138             self.__field_msg=LIST(value,**{'elementclass': _gen_p_lglx570_191, 'length': 181})
2139 
2140     def __delfield_msg(self): del self.__field_msg
2141 
2142     msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None)
2143 
2144     def iscontainer(self):
2145         return True
2146 
2147     def containerelements(self):
2148         yield ('msg', self.__field_msg, None)
2149 
2150 
2151 
2152 
2153 class _gen_p_lglx570_191(BaseProtogenClass):
2154     'Anonymous inner class'
2155     __fields=['byte']
2156 
2157     def __init__(self, *args, **kwargs):
2158         dict={}
2159         # What was supplied to this function
2160         dict.update(kwargs)
2161         # Parent constructor
2162         super(_gen_p_lglx570_191,self).__init__(**dict)
2163         if self.__class__ is _gen_p_lglx570_191:
2164             self._update(args,dict)
2165 
2166 
2167     def getfields(self):
2168         return self.__fields
2169 
2170 
2171     def _update(self, args, kwargs):
2172         super(_gen_p_lglx570_191,self)._update(args,kwargs)
2173         keys=kwargs.keys()
2174         for key in keys:
2175             if key in self.__fields:
2176                 setattr(self, key, kwargs[key])
2177                 del kwargs[key]
2178         # Were any unrecognized kwargs passed in?
2179         if __debug__:
2180             self._complainaboutunusedargs(_gen_p_lglx570_191,kwargs)
2181         if len(args):
2182             dict2={'sizeinbytes': 1}
2183             dict2.update(kwargs)
2184             kwargs=dict2
2185             self.__field_byte=UINT(*args,**dict2)
2186         # Make all P fields that haven't already been constructed
2187 
2188 
2189     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2190         'Writes this packet to the supplied buffer'
2191         self._bufferstartoffset=buf.getcurrentoffset()
2192         self.__field_byte.writetobuffer(buf)
2193         self._bufferendoffset=buf.getcurrentoffset()
2194         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2195 
2196 
2197     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2198         'Reads this packet from the supplied buffer'
2199         self._bufferstartoffset=buf.getcurrentoffset()
2200         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2201         self.__field_byte=UINT(**{'sizeinbytes': 1})
2202         self.__field_byte.readfrombuffer(buf)
2203         self._bufferendoffset=buf.getcurrentoffset()
2204 
2205 
2206     def __getfield_byte(self):
2207         return self.__field_byte.getvalue()
2208 
2209     def __setfield_byte(self, value):
2210         if isinstance(value,UINT):
2211             self.__field_byte=value
2212         else:
2213             self.__field_byte=UINT(value,**{'sizeinbytes': 1})
2214 
2215     def __delfield_byte(self): del self.__field_byte
2216 
2217     byte=property(__getfield_byte, __setfield_byte, __delfield_byte, "individual byte of message")
2218 
2219     def iscontainer(self):
2220         return True
2221 
2222     def containerelements(self):
2223         yield ('byte', self.__field_byte, "individual byte of message")
2224 
2225 
2226 
2227 
2228 class sms_in(BaseProtogenClass):
2229     __fields=['unknown1', 'msg_index2', 'unknown2', 'timesent', 'unknown', 'callback_length', 'callback', 'sender_length', 'sender', 'unknown4', 'lg_time', 'GPStime', 'dunno1', 'read', 'locked', 'unknown5', 'subject', 'msglength', 'msg']
2230 
2231     def __init__(self, *args, **kwargs):
2232         dict={}
2233         # What was supplied to this function
2234         dict.update(kwargs)
2235         # Parent constructor
2236         super(sms_in,self).__init__(**dict)
2237         if self.__class__ is sms_in:
2238             self._update(args,dict)
2239 
2240 
2241     def getfields(self):
2242         return self.__fields
2243 
2244 
2245     def _update(self, args, kwargs):
2246         super(sms_in,self)._update(args,kwargs)
2247         keys=kwargs.keys()
2248         for key in keys:
2249             if key in self.__fields:
2250                 setattr(self, key, kwargs[key])
2251                 del kwargs[key]
2252         # Were any unrecognized kwargs passed in?
2253         if __debug__:
2254             self._complainaboutunusedargs(sms_in,kwargs)
2255         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2256         # Make all P fields that haven't already been constructed
2257 
2258 
2259     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2260         'Writes this packet to the supplied buffer'
2261         self._bufferstartoffset=buf.getcurrentoffset()
2262         self.__field_unknown1.writetobuffer(buf)
2263         self.__field_msg_index2.writetobuffer(buf)
2264         self.__field_unknown2.writetobuffer(buf)
2265         self.__field_timesent.writetobuffer(buf)
2266         self.__field_unknown.writetobuffer(buf)
2267         self.__field_callback_length.writetobuffer(buf)
2268         self.__field_callback.writetobuffer(buf)
2269         self.__field_sender_length.writetobuffer(buf)
2270         try: self.__field_sender
2271         except:
2272             self.__field_sender=LIST(**{'elementclass': _gen_p_lglx570_203, 'length': 38})
2273         self.__field_sender.writetobuffer(buf)
2274         self.__field_unknown4.writetobuffer(buf)
2275         self.__field_lg_time.writetobuffer(buf)
2276         self.__field_GPStime.writetobuffer(buf)
2277         self.__field_dunno1.writetobuffer(buf)
2278         self.__field_read.writetobuffer(buf)
2279         self.__field_locked.writetobuffer(buf)
2280         self.__field_unknown5.writetobuffer(buf)
2281         self.__field_subject.writetobuffer(buf)
2282         self.__field_msglength.writetobuffer(buf)
2283         self.__field_msg.writetobuffer(buf)
2284         self._bufferendoffset=buf.getcurrentoffset()
2285         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2286 
2287 
2288     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2289         'Reads this packet from the supplied buffer'
2290         self._bufferstartoffset=buf.getcurrentoffset()
2291         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2292         self.__field_unknown1=UINT(**{'sizeinbytes': 4})
2293         self.__field_unknown1.readfrombuffer(buf)
2294         self.__field_msg_index2=UINT(**{'sizeinbytes': 4})
2295         self.__field_msg_index2.readfrombuffer(buf)
2296         self.__field_unknown2=UINT(**{'sizeinbytes': 2})
2297         self.__field_unknown2.readfrombuffer(buf)
2298         self.__field_timesent=SMSDATE(**{'sizeinbytes': 6})
2299         self.__field_timesent.readfrombuffer(buf)
2300         self.__field_unknown=UINT(**{'sizeinbytes': 3})
2301         self.__field_unknown.readfrombuffer(buf)
2302         self.__field_callback_length=UINT(**{'sizeinbytes': 1})
2303         self.__field_callback_length.readfrombuffer(buf)
2304         self.__field_callback=USTRING(**{'sizeinbytes': 42})
2305         self.__field_callback.readfrombuffer(buf)
2306         self.__field_sender_length=UINT(**{'sizeinbytes': 1})
2307         self.__field_sender_length.readfrombuffer(buf)
2308         self.__field_sender=LIST(**{'elementclass': _gen_p_lglx570_203, 'length': 38})
2309         self.__field_sender.readfrombuffer(buf)
2310         self.__field_unknown4=DATA(**{'sizeinbytes': 15})
2311         self.__field_unknown4.readfrombuffer(buf)
2312         self.__field_lg_time=LGCALDATE(**{'sizeinbytes': 4})
2313         self.__field_lg_time.readfrombuffer(buf)
2314         self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4})
2315         self.__field_GPStime.readfrombuffer(buf)
2316         self.__field_dunno1=DATA(**{'sizeinbytes': 5})
2317         self.__field_dunno1.readfrombuffer(buf)
2318         self.__field_read=UINT(**{'sizeinbytes': 1})
2319         self.__field_read.readfrombuffer(buf)
2320         self.__field_locked=UINT(**{'sizeinbytes': 1})
2321         self.__field_locked.readfrombuffer(buf)
2322         self.__field_unknown5=DATA(**{'sizeinbytes': 7})
2323         self.__field_unknown5.readfrombuffer(buf)
2324         self.__field_subject=USTRING(**{'sizeinbytes': 74, 'encoding': PHONE_ENCODING})
2325         self.__field_subject.readfrombuffer(buf)
2326         self.__field_msglength=UINT(**{'sizeinbytes': 2})
2327         self.__field_msglength.readfrombuffer(buf)
2328         self.__field_msg=USTRING(**{'sizeinbytes': 1030, 'encoding': PHONE_ENCODING})
2329         self.__field_msg.readfrombuffer(buf)
2330         self._bufferendoffset=buf.getcurrentoffset()
2331 
2332 
2333     def __getfield_unknown1(self):
2334         return self.__field_unknown1.getvalue()
2335 
2336     def __setfield_unknown1(self, value):
2337         if isinstance(value,UINT):
2338             self.__field_unknown1=value
2339         else:
2340             self.__field_unknown1=UINT(value,**{'sizeinbytes': 4})
2341 
2342     def __delfield_unknown1(self): del self.__field_unknown1
2343 
2344     unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None)
2345 
2346     def __getfield_msg_index2(self):
2347         return self.__field_msg_index2.getvalue()
2348 
2349     def __setfield_msg_index2(self, value):
2350         if isinstance(value,UINT):
2351             self.__field_msg_index2=value
2352         else:
2353             self.__field_msg_index2=UINT(value,**{'sizeinbytes': 4})
2354 
2355     def __delfield_msg_index2(self): del self.__field_msg_index2
2356 
2357     msg_index2=property(__getfield_msg_index2, __setfield_msg_index2, __delfield_msg_index2, None)
2358 
2359     def __getfield_unknown2(self):
2360         return self.__field_unknown2.getvalue()
2361 
2362     def __setfield_unknown2(self, value):
2363         if isinstance(value,UINT):
2364             self.__field_unknown2=value
2365         else:
2366             self.__field_unknown2=UINT(value,**{'sizeinbytes': 2})
2367 
2368     def __delfield_unknown2(self): del self.__field_unknown2
2369 
2370     unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None)
2371 
2372     def __getfield_timesent(self):
2373         return self.__field_timesent.getvalue()
2374 
2375     def __setfield_timesent(self, value):
2376         if isinstance(value,SMSDATE):
2377             self.__field_timesent=value
2378         else:
2379             self.__field_timesent=SMSDATE(value,**{'sizeinbytes': 6})
2380 
2381     def __delfield_timesent(self): del self.__field_timesent
2382 
2383     timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None)
2384 
2385     def __getfield_unknown(self):
2386         return self.__field_unknown.getvalue()
2387 
2388     def __setfield_unknown(self, value):
2389         if isinstance(value,UINT):
2390             self.__field_unknown=value
2391         else:
2392             self.__field_unknown=UINT(value,**{'sizeinbytes': 3})
2393 
2394     def __delfield_unknown(self): del self.__field_unknown
2395 
2396     unknown=property(__getfield_unknown, __setfield_unknown, __delfield_unknown, None)
2397 
2398     def __getfield_callback_length(self):
2399         return self.__field_callback_length.getvalue()
2400 
2401     def __setfield_callback_length(self, value):
2402         if isinstance(value,UINT):
2403             self.__field_callback_length=value
2404         else:
2405             self.__field_callback_length=UINT(value,**{'sizeinbytes': 1})
2406 
2407     def __delfield_callback_length(self): del self.__field_callback_length
2408 
2409     callback_length=property(__getfield_callback_length, __setfield_callback_length, __delfield_callback_length, None)
2410 
2411     def __getfield_callback(self):
2412         return self.__field_callback.getvalue()
2413 
2414     def __setfield_callback(self, value):
2415         if isinstance(value,USTRING):
2416             self.__field_callback=value
2417         else:
2418             self.__field_callback=USTRING(value,**{'sizeinbytes': 42})
2419 
2420     def __delfield_callback(self): del self.__field_callback
2421 
2422     callback=property(__getfield_callback, __setfield_callback, __delfield_callback, None)
2423 
2424     def __getfield_sender_length(self):
2425         return self.__field_sender_length.getvalue()
2426 
2427     def __setfield_sender_length(self, value):
2428         if isinstance(value,UINT):
2429             self.__field_sender_length=value
2430         else:
2431             self.__field_sender_length=UINT(value,**{'sizeinbytes': 1})
2432 
2433     def __delfield_sender_length(self): del self.__field_sender_length
2434 
2435     sender_length=property(__getfield_sender_length, __setfield_sender_length, __delfield_sender_length, None)
2436 
2437     def __getfield_sender(self):
2438         try: self.__field_sender
2439         except:
2440             self.__field_sender=LIST(**{'elementclass': _gen_p_lglx570_203, 'length': 38})
2441         return self.__field_sender.getvalue()
2442 
2443     def __setfield_sender(self, value):
2444         if isinstance(value,LIST):
2445             self.__field_sender=value
2446         else:
2447             self.__field_sender=LIST(value,**{'elementclass': _gen_p_lglx570_203, 'length': 38})
2448 
2449     def __delfield_sender(self): del self.__field_sender
2450 
2451     sender=property(__getfield_sender, __setfield_sender, __delfield_sender, None)
2452 
2453     def __getfield_unknown4(self):
2454         return self.__field_unknown4.getvalue()
2455 
2456     def __setfield_unknown4(self, value):
2457         if isinstance(value,DATA):
2458             self.__field_unknown4=value
2459         else:
2460             self.__field_unknown4=DATA(value,**{'sizeinbytes': 15})
2461 
2462     def __delfield_unknown4(self): del self.__field_unknown4
2463 
2464     unknown4=property(__getfield_unknown4, __setfield_unknown4, __delfield_unknown4, None)
2465 
2466     def __getfield_lg_time(self):
2467         return self.__field_lg_time.getvalue()
2468 
2469     def __setfield_lg_time(self, value):
2470         if isinstance(value,LGCALDATE):
2471             self.__field_lg_time=value
2472         else:
2473             self.__field_lg_time=LGCALDATE(value,**{'sizeinbytes': 4})
2474 
2475     def __delfield_lg_time(self): del self.__field_lg_time
2476 
2477     lg_time=property(__getfield_lg_time, __setfield_lg_time, __delfield_lg_time, None)
2478 
2479     def __getfield_GPStime(self):
2480         return self.__field_GPStime.getvalue()
2481 
2482     def __setfield_GPStime(self, value):
2483         if isinstance(value,GPSDATE):
2484             self.__field_GPStime=value
2485         else:
2486             self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4})
2487 
2488     def __delfield_GPStime(self): del self.__field_GPStime
2489 
2490     GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None)
2491 
2492     def __getfield_dunno1(self):
2493         return self.__field_dunno1.getvalue()
2494 
2495     def __setfield_dunno1(self, value):
2496         if isinstance(value,DATA):
2497             self.__field_dunno1=value
2498         else:
2499             self.__field_dunno1=DATA(value,**{'sizeinbytes': 5})
2500 
2501     def __delfield_dunno1(self): del self.__field_dunno1
2502 
2503     dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None)
2504 
2505     def __getfield_read(self):
2506         return self.__field_read.getvalue()
2507 
2508     def __setfield_read(self, value):
2509         if isinstance(value,UINT):
2510             self.__field_read=value
2511         else:
2512             self.__field_read=UINT(value,**{'sizeinbytes': 1})
2513 
2514     def __delfield_read(self): del self.__field_read
2515 
2516     read=property(__getfield_read, __setfield_read, __delfield_read, None)
2517 
2518     def __getfield_locked(self):
2519         return self.__field_locked.getvalue()
2520 
2521     def __setfield_locked(self, value):
2522         if isinstance(value,UINT):
2523             self.__field_locked=value
2524         else:
2525             self.__field_locked=UINT(value,**{'sizeinbytes': 1})
2526 
2527     def __delfield_locked(self): del self.__field_locked
2528 
2529     locked=property(__getfield_locked, __setfield_locked, __delfield_locked, None)
2530 
2531     def __getfield_unknown5(self):
2532         return self.__field_unknown5.getvalue()
2533 
2534     def __setfield_unknown5(self, value):
2535         if isinstance(value,DATA):
2536             self.__field_unknown5=value
2537         else:
2538             self.__field_unknown5=DATA(value,**{'sizeinbytes': 7})
2539 
2540     def __delfield_unknown5(self): del self.__field_unknown5
2541 
2542     unknown5=property(__getfield_unknown5, __setfield_unknown5, __delfield_unknown5, None)
2543 
2544     def __getfield_subject(self):
2545         return self.__field_subject.getvalue()
2546 
2547     def __setfield_subject(self, value):
2548         if isinstance(value,USTRING):
2549             self.__field_subject=value
2550         else:
2551             self.__field_subject=USTRING(value,**{'sizeinbytes': 74, 'encoding': PHONE_ENCODING})
2552 
2553     def __delfield_subject(self): del self.__field_subject
2554 
2555     subject=property(__getfield_subject, __setfield_subject, __delfield_subject, None)
2556 
2557     def __getfield_msglength(self):
2558         return self.__field_msglength.getvalue()
2559 
2560     def __setfield_msglength(self, value):
2561         if isinstance(value,UINT):
2562             self.__field_msglength=value
2563         else:
2564             self.__field_msglength=UINT(value,**{'sizeinbytes': 2})
2565 
2566     def __delfield_msglength(self): del self.__field_msglength
2567 
2568     msglength=property(__getfield_msglength, __setfield_msglength, __delfield_msglength, None)
2569 
2570     def __getfield_msg(self):
2571         return self.__field_msg.getvalue()
2572 
2573     def __setfield_msg(self, value):
2574         if isinstance(value,USTRING):
2575             self.__field_msg=value
2576         else:
2577             self.__field_msg=USTRING(value,**{'sizeinbytes': 1030, 'encoding': PHONE_ENCODING})
2578 
2579     def __delfield_msg(self): del self.__field_msg
2580 
2581     msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None)
2582 
2583     def iscontainer(self):
2584         return True
2585 
2586     def containerelements(self):
2587         yield ('unknown1', self.__field_unknown1, None)
2588         yield ('msg_index2', self.__field_msg_index2, None)
2589         yield ('unknown2', self.__field_unknown2, None)
2590         yield ('timesent', self.__field_timesent, None)
2591         yield ('unknown', self.__field_unknown, None)
2592         yield ('callback_length', self.__field_callback_length, None)
2593         yield ('callback', self.__field_callback, None)
2594         yield ('sender_length', self.__field_sender_length, None)
2595         yield ('sender', self.__field_sender, None)
2596         yield ('unknown4', self.__field_unknown4, None)
2597         yield ('lg_time', self.__field_lg_time, None)
2598         yield ('GPStime', self.__field_GPStime, None)
2599         yield ('dunno1', self.__field_dunno1, None)
2600         yield ('read', self.__field_read, None)
2601         yield ('locked', self.__field_locked, None)
2602         yield ('unknown5', self.__field_unknown5, None)
2603         yield ('subject', self.__field_subject, None)
2604         yield ('msglength', self.__field_msglength, None)
2605         yield ('msg', self.__field_msg, None)
2606 
2607 
2608 
2609 
2610 class _gen_p_lglx570_203(BaseProtogenClass):
2611     'Anonymous inner class'
2612     __fields=['byte']
2613 
2614     def __init__(self, *args, **kwargs):
2615         dict={}
2616         # What was supplied to this function
2617         dict.update(kwargs)
2618         # Parent constructor
2619         super(_gen_p_lglx570_203,self).__init__(**dict)
2620         if self.__class__ is _gen_p_lglx570_203:
2621             self._update(args,dict)
2622 
2623 
2624     def getfields(self):
2625         return self.__fields
2626 
2627 
2628     def _update(self, args, kwargs):
2629         super(_gen_p_lglx570_203,self)._update(args,kwargs)
2630         keys=kwargs.keys()
2631         for key in keys:
2632             if key in self.__fields:
2633                 setattr(self, key, kwargs[key])
2634                 del kwargs[key]
2635         # Were any unrecognized kwargs passed in?
2636         if __debug__:
2637             self._complainaboutunusedargs(_gen_p_lglx570_203,kwargs)
2638         if len(args):
2639             dict2={'sizeinbytes': 1}
2640             dict2.update(kwargs)
2641             kwargs=dict2
2642             self.__field_byte=UINT(*args,**dict2)
2643         # Make all P fields that haven't already been constructed
2644 
2645 
2646     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2647         'Writes this packet to the supplied buffer'
2648         self._bufferstartoffset=buf.getcurrentoffset()
2649         self.__field_byte.writetobuffer(buf)
2650         self._bufferendoffset=buf.getcurrentoffset()
2651         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2652 
2653 
2654     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2655         'Reads this packet from the supplied buffer'
2656         self._bufferstartoffset=buf.getcurrentoffset()
2657         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2658         self.__field_byte=UINT(**{'sizeinbytes': 1})
2659         self.__field_byte.readfrombuffer(buf)
2660         self._bufferendoffset=buf.getcurrentoffset()
2661 
2662 
2663     def __getfield_byte(self):
2664         return self.__field_byte.getvalue()
2665 
2666     def __setfield_byte(self, value):
2667         if isinstance(value,UINT):
2668             self.__field_byte=value
2669         else:
2670             self.__field_byte=UINT(value,**{'sizeinbytes': 1})
2671 
2672     def __delfield_byte(self): del self.__field_byte
2673 
2674     byte=property(__getfield_byte, __setfield_byte, __delfield_byte, "individual byte of senders phone number")
2675 
2676     def iscontainer(self):
2677         return True
2678 
2679     def containerelements(self):
2680         yield ('byte', self.__field_byte, "individual byte of senders phone number")
2681 
2682 
2683 
2684 
2685 class sms_quick_text(BaseProtogenClass):
2686     __fields=['msg']
2687 
2688     def __init__(self, *args, **kwargs):
2689         dict={}
2690         # What was supplied to this function
2691         dict.update(kwargs)
2692         # Parent constructor
2693         super(sms_quick_text,self).__init__(**dict)
2694         if self.__class__ is sms_quick_text:
2695             self._update(args,dict)
2696 
2697 
2698     def getfields(self):
2699         return self.__fields
2700 
2701 
2702     def _update(self, args, kwargs):
2703         super(sms_quick_text,self)._update(args,kwargs)
2704         keys=kwargs.keys()
2705         for key in keys:
2706             if key in self.__fields:
2707                 setattr(self, key, kwargs[key])
2708                 del kwargs[key]
2709         # Were any unrecognized kwargs passed in?
2710         if __debug__:
2711             self._complainaboutunusedargs(sms_quick_text,kwargs)
2712         if len(args):
2713             dict2={'sizeinbytes': 101, 'encoding': PHONE_ENCODING,                 'default': ""}
2714             dict2.update(kwargs)
2715             kwargs=dict2
2716             self.__field_msg=USTRING(*args,**dict2)
2717         # Make all P fields that haven't already been constructed
2718 
2719 
2720     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2721         'Writes this packet to the supplied buffer'
2722         self._bufferstartoffset=buf.getcurrentoffset()
2723         try: self.__field_msg
2724         except:
2725             self.__field_msg=USTRING(**{'sizeinbytes': 101, 'encoding': PHONE_ENCODING,                 'default': ""})
2726         self.__field_msg.writetobuffer(buf)
2727         self._bufferendoffset=buf.getcurrentoffset()
2728         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2729 
2730 
2731     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2732         'Reads this packet from the supplied buffer'
2733         self._bufferstartoffset=buf.getcurrentoffset()
2734         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2735         self.__field_msg=USTRING(**{'sizeinbytes': 101, 'encoding': PHONE_ENCODING,                 'default': ""})
2736         self.__field_msg.readfrombuffer(buf)
2737         self._bufferendoffset=buf.getcurrentoffset()
2738 
2739 
2740     def __getfield_msg(self):
2741         try: self.__field_msg
2742         except:
2743             self.__field_msg=USTRING(**{'sizeinbytes': 101, 'encoding': PHONE_ENCODING,                 'default': ""})
2744         return self.__field_msg.getvalue()
2745 
2746     def __setfield_msg(self, value):
2747         if isinstance(value,USTRING):
2748             self.__field_msg=value
2749         else:
2750             self.__field_msg=USTRING(value,**{'sizeinbytes': 101, 'encoding': PHONE_ENCODING,                 'default': ""})
2751 
2752     def __delfield_msg(self): del self.__field_msg
2753 
2754     msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None)
2755 
2756     def iscontainer(self):
2757         return True
2758 
2759     def containerelements(self):
2760         yield ('msg', self.__field_msg, None)
2761 
2762 
2763 
2764 
2765 class sms_canned_file(BaseProtogenClass):
2766     __fields=['num_active', 'msgs']
2767 
2768     def __init__(self, *args, **kwargs):
2769         dict={}
2770         # What was supplied to this function
2771         dict.update(kwargs)
2772         # Parent constructor
2773         super(sms_canned_file,self).__init__(**dict)
2774         if self.__class__ is sms_canned_file:
2775             self._update(args,dict)
2776 
2777 
2778     def getfields(self):
2779         return self.__fields
2780 
2781 
2782     def _update(self, args, kwargs):
2783         super(sms_canned_file,self)._update(args,kwargs)
2784         keys=kwargs.keys()
2785         for key in keys:
2786             if key in self.__fields:
2787                 setattr(self, key, kwargs[key])
2788                 del kwargs[key]
2789         # Were any unrecognized kwargs passed in?
2790         if __debug__:
2791             self._complainaboutunusedargs(sms_canned_file,kwargs)
2792         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2793         # Make all P fields that haven't already been constructed
2794 
2795 
2796     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2797         'Writes this packet to the supplied buffer'
2798         self._bufferstartoffset=buf.getcurrentoffset()
2799         try: self.__field_num_active
2800         except:
2801             self.__field_num_active=UINT(**{'sizeinbytes': 2,  'default': len(self.msgs) })
2802         self.__field_num_active.writetobuffer(buf)
2803         try: self.__field_msgs
2804         except:
2805             self.__field_msgs=LIST(**{'length': SMS_CANNED_MAX_ITEMS,            'createdefault': True,            'elementclass': sms_quick_text})
2806         self.__field_msgs.writetobuffer(buf)
2807         self._bufferendoffset=buf.getcurrentoffset()
2808         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2809 
2810 
2811     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2812         'Reads this packet from the supplied buffer'
2813         self._bufferstartoffset=buf.getcurrentoffset()
2814         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2815         self.__field_num_active=UINT(**{'sizeinbytes': 2,  'default': len(self.msgs) })
2816         self.__field_num_active.readfrombuffer(buf)
2817         self.__field_msgs=LIST(**{'length': SMS_CANNED_MAX_ITEMS,            'createdefault': True,            'elementclass': sms_quick_text})
2818         self.__field_msgs.readfrombuffer(buf)
2819         self._bufferendoffset=buf.getcurrentoffset()
2820 
2821 
2822     def __getfield_num_active(self):
2823         try: self.__field_num_active
2824         except:
2825             self.__field_num_active=UINT(**{'sizeinbytes': 2,  'default': len(self.msgs) })
2826         return self.__field_num_active.getvalue()
2827 
2828     def __setfield_num_active(self, value):
2829         if isinstance(value,UINT):
2830             self.__field_num_active=value
2831         else:
2832             self.__field_num_active=UINT(value,**{'sizeinbytes': 2,  'default': len(self.msgs) })
2833 
2834     def __delfield_num_active(self): del self.__field_num_active
2835 
2836     num_active=property(__getfield_num_active, __setfield_num_active, __delfield_num_active, None)
2837 
2838     def __getfield_msgs(self):
2839         try: self.__field_msgs
2840         except:
2841             self.__field_msgs=LIST(**{'length': SMS_CANNED_MAX_ITEMS,            'createdefault': True,            'elementclass': sms_quick_text})
2842         return self.__field_msgs.getvalue()
2843 
2844     def __setfield_msgs(self, value):
2845         if isinstance(value,LIST):
2846             self.__field_msgs=value
2847         else:
2848             self.__field_msgs=LIST(value,**{'length': SMS_CANNED_MAX_ITEMS,            'createdefault': True,            'elementclass': sms_quick_text})
2849 
2850     def __delfield_msgs(self): del self.__field_msgs
2851 
2852     msgs=property(__getfield_msgs, __setfield_msgs, __delfield_msgs, None)
2853 
2854     def iscontainer(self):
2855         return True
2856 
2857     def containerelements(self):
2858         yield ('num_active', self.__field_num_active, None)
2859         yield ('msgs', self.__field_msgs, None)
2860 
2861 
2862 
2863 
2864