PyXR

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

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