PyXR

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

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