PyXR

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

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