PyXR

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



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

Generated by PyXR 0.9.4