PyXR

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

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