PyXR

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

0001 # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE
0002 
0003 """Various descriptions of data specific to the Samsung SCH-U470 (Juke) Phone"""
0004 
0005 from prototypes import *
0006 from prototypes_samsung import *
0007 from p_brew import *
0008 from p_samsungschu740 import *
0009 
0010 PB_FLG2_RINGTONE=0x0001
0011 PB_FLG2_WP=0x0002
0012 
0013 CL_MAX_ENTRIES=90
0014 
0015 class NumberEntry(BaseProtogenClass):
0016     __fields=['number', 'option', 'speeddial', 'ringtone']
0017 
0018     def __init__(self, *args, **kwargs):
0019         dict={}
0020         # What was supplied to this function
0021         dict.update(kwargs)
0022         # Parent constructor
0023         super(NumberEntry,self).__init__(**dict)
0024         if self.__class__ is NumberEntry:
0025             self._update(args,dict)
0026 
0027 
0028     def getfields(self):
0029         return self.__fields
0030 
0031 
0032     def _update(self, args, kwargs):
0033         super(NumberEntry,self)._update(args,kwargs)
0034         keys=kwargs.keys()
0035         for key in keys:
0036             if key in self.__fields:
0037                 setattr(self, key, kwargs[key])
0038                 del kwargs[key]
0039         # Were any unrecognized kwargs passed in?
0040         if __debug__:
0041             self._complainaboutunusedargs(NumberEntry,kwargs)
0042         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0043         # Make all P fields that haven't already been constructed
0044 
0045 
0046     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0047         'Writes this packet to the supplied buffer'
0048         self._bufferstartoffset=buf.getcurrentoffset()
0049         self.__field_number.writetobuffer(buf)
0050         self.__field_option.writetobuffer(buf)
0051         if self.option & PB_FLG_SPEEDDIAL:
0052             self.__field_speeddial.writetobuffer(buf)
0053         if self.option & PB_FLG_RINGTONE:
0054             self.__field_ringtone.writetobuffer(buf)
0055         self._bufferendoffset=buf.getcurrentoffset()
0056         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0057 
0058 
0059     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0060         'Reads this packet from the supplied buffer'
0061         self._bufferstartoffset=buf.getcurrentoffset()
0062         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0063         self.__field_number=STRING(**{ 'terminator': None,               'pascal': True })
0064         self.__field_number.readfrombuffer(buf)
0065         self.__field_option=UINT(**{'sizeinbytes': 1})
0066         self.__field_option.readfrombuffer(buf)
0067         if self.option & PB_FLG_SPEEDDIAL:
0068             self.__field_speeddial=UINT(**{'sizeinbytes': 2})
0069             self.__field_speeddial.readfrombuffer(buf)
0070         if self.option & PB_FLG_RINGTONE:
0071             self.__field_ringtone=STRING(**{ 'terminator': None,                   'pascal': True })
0072             self.__field_ringtone.readfrombuffer(buf)
0073         self._bufferendoffset=buf.getcurrentoffset()
0074 
0075 
0076     def __getfield_number(self):
0077         return self.__field_number.getvalue()
0078 
0079     def __setfield_number(self, value):
0080         if isinstance(value,STRING):
0081             self.__field_number=value
0082         else:
0083             self.__field_number=STRING(value,**{ 'terminator': None,               'pascal': True })
0084 
0085     def __delfield_number(self): del self.__field_number
0086 
0087     number=property(__getfield_number, __setfield_number, __delfield_number, None)
0088 
0089     def __getfield_option(self):
0090         return self.__field_option.getvalue()
0091 
0092     def __setfield_option(self, value):
0093         if isinstance(value,UINT):
0094             self.__field_option=value
0095         else:
0096             self.__field_option=UINT(value,**{'sizeinbytes': 1})
0097 
0098     def __delfield_option(self): del self.__field_option
0099 
0100     option=property(__getfield_option, __setfield_option, __delfield_option, None)
0101 
0102     def __getfield_speeddial(self):
0103         return self.__field_speeddial.getvalue()
0104 
0105     def __setfield_speeddial(self, value):
0106         if isinstance(value,UINT):
0107             self.__field_speeddial=value
0108         else:
0109             self.__field_speeddial=UINT(value,**{'sizeinbytes': 2})
0110 
0111     def __delfield_speeddial(self): del self.__field_speeddial
0112 
0113     speeddial=property(__getfield_speeddial, __setfield_speeddial, __delfield_speeddial, None)
0114 
0115     def __getfield_ringtone(self):
0116         return self.__field_ringtone.getvalue()
0117 
0118     def __setfield_ringtone(self, value):
0119         if isinstance(value,STRING):
0120             self.__field_ringtone=value
0121         else:
0122             self.__field_ringtone=STRING(value,**{ 'terminator': None,                   'pascal': True })
0123 
0124     def __delfield_ringtone(self): del self.__field_ringtone
0125 
0126     ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None)
0127 
0128     def iscontainer(self):
0129         return True
0130 
0131     def containerelements(self):
0132         yield ('number', self.__field_number, None)
0133         yield ('option', self.__field_option, None)
0134         if self.option & PB_FLG_SPEEDDIAL:
0135             yield ('speeddial', self.__field_speeddial, None)
0136         if self.option & PB_FLG_RINGTONE:
0137             yield ('ringtone', self.__field_ringtone, None)
0138 
0139 
0140 
0141 
0142 class PBEntry(BaseProtogenClass):
0143     __fields=['info', 'info2', 'name', 'email', 'email2', 'home', 'work', 'cell', 'fax', 'cell2', 'note', 'datetime', 'group', 'wallpaper', 'wallpaper_range', 'ringtone', 'wallpaper2']
0144 
0145     def __init__(self, *args, **kwargs):
0146         dict={}
0147         # What was supplied to this function
0148         dict.update(kwargs)
0149         # Parent constructor
0150         super(PBEntry,self).__init__(**dict)
0151         if self.__class__ is PBEntry:
0152             self._update(args,dict)
0153 
0154 
0155     def getfields(self):
0156         return self.__fields
0157 
0158 
0159     def _update(self, args, kwargs):
0160         super(PBEntry,self)._update(args,kwargs)
0161         keys=kwargs.keys()
0162         for key in keys:
0163             if key in self.__fields:
0164                 setattr(self, key, kwargs[key])
0165                 del kwargs[key]
0166         # Were any unrecognized kwargs passed in?
0167         if __debug__:
0168             self._complainaboutunusedargs(PBEntry,kwargs)
0169         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0170         # Make all P fields that haven't already been constructed
0171 
0172 
0173     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0174         'Writes this packet to the supplied buffer'
0175         self._bufferstartoffset=buf.getcurrentoffset()
0176         self.__field_info.writetobuffer(buf)
0177         self.__field_info2.writetobuffer(buf)
0178         if self.info & PB_FLG_NAME:
0179             self.__field_name.writetobuffer(buf)
0180         if self.info & PB_FLG_EMAIL:
0181             self.__field_email.writetobuffer(buf)
0182         if self.info & PB_FLG_EMAIL2:
0183             self.__field_email2.writetobuffer(buf)
0184         if self.info & PB_FLG_HOME:
0185             self.__field_home.writetobuffer(buf)
0186         if self.info & PB_FLG_WORK:
0187             self.__field_work.writetobuffer(buf)
0188         if self.info & PB_FLG_CELL:
0189             self.__field_cell.writetobuffer(buf)
0190         if self.info & PB_FLG_FAX:
0191             self.__field_fax.writetobuffer(buf)
0192         if self.info & PB_FLG_CELL2:
0193             self.__field_cell2.writetobuffer(buf)
0194         if self.info & PB_FLG_NOTE:
0195             self.__field_note.writetobuffer(buf)
0196         if self.info & PB_FLG_DATE:
0197             self.__field_datetime.writetobuffer(buf)
0198         if self.info & PB_FLG_GROUP:
0199             self.__field_group.writetobuffer(buf)
0200         if self.info & PB_FLG_WP:
0201             self.__field_wallpaper.writetobuffer(buf)
0202             self.__field_wallpaper_range.writetobuffer(buf)
0203         if self.info2 & PB_FLG2_RINGTONE:
0204             self.__field_ringtone.writetobuffer(buf)
0205         if self.info2 & PB_FLG2_WP:
0206             self.__field_wallpaper2.writetobuffer(buf)
0207         self._bufferendoffset=buf.getcurrentoffset()
0208         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0209 
0210 
0211     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0212         'Reads this packet from the supplied buffer'
0213         self._bufferstartoffset=buf.getcurrentoffset()
0214         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0215         self.__field_info=UINT(**{'sizeinbytes': 2})
0216         self.__field_info.readfrombuffer(buf)
0217         self.__field_info2=UINT(**{'sizeinbytes': 2})
0218         self.__field_info2.readfrombuffer(buf)
0219         if self.info & PB_FLG_NAME:
0220             self.__field_name=USTRING(**{ 'terminator': None,                    'encoding': ENCODING,                    'pascal': True })
0221             self.__field_name.readfrombuffer(buf)
0222         if self.info & PB_FLG_EMAIL:
0223             self.__field_email=USTRING(**{ 'terminator': None,                    'encoding': ENCODING,                    'pascal': True })
0224             self.__field_email.readfrombuffer(buf)
0225         if self.info & PB_FLG_EMAIL2:
0226             self.__field_email2=USTRING(**{ 'terminator': None,                    'encoding': ENCODING,                   'pascal': True })
0227             self.__field_email2.readfrombuffer(buf)
0228         if self.info & PB_FLG_HOME:
0229             self.__field_home=NumberEntry()
0230             self.__field_home.readfrombuffer(buf)
0231         if self.info & PB_FLG_WORK:
0232             self.__field_work=NumberEntry()
0233             self.__field_work.readfrombuffer(buf)
0234         if self.info & PB_FLG_CELL:
0235             self.__field_cell=NumberEntry()
0236             self.__field_cell.readfrombuffer(buf)
0237         if self.info & PB_FLG_FAX:
0238             self.__field_fax=NumberEntry()
0239             self.__field_fax.readfrombuffer(buf)
0240         if self.info & PB_FLG_CELL2:
0241             self.__field_cell2=NumberEntry()
0242             self.__field_cell2.readfrombuffer(buf)
0243         if self.info & PB_FLG_NOTE:
0244             self.__field_note=STRING(**{ 'terminator': None,                   'pascal': True })
0245             self.__field_note.readfrombuffer(buf)
0246         if self.info & PB_FLG_DATE:
0247             self.__field_datetime=DateTime(**{'sizeinbytes': 4})
0248             self.__field_datetime.readfrombuffer(buf)
0249         if self.info & PB_FLG_GROUP:
0250             self.__field_group=UINT(**{'sizeinbytes': 1})
0251             self.__field_group.readfrombuffer(buf)
0252         if self.info & PB_FLG_WP:
0253             self.__field_wallpaper=STRING(**{ 'terminator': None,                   'pascal': True })
0254             self.__field_wallpaper.readfrombuffer(buf)
0255             self.__field_wallpaper_range=UINT(**{'sizeinbytes': 4})
0256             self.__field_wallpaper_range.readfrombuffer(buf)
0257         if self.info2 & PB_FLG2_RINGTONE:
0258             self.__field_ringtone=STRING(**{ 'terminator': None,                   'pascal': True })
0259             self.__field_ringtone.readfrombuffer(buf)
0260         if self.info2 & PB_FLG2_WP:
0261             self.__field_wallpaper2=STRING(**{ 'terminator': None,                   'pascal': True })
0262             self.__field_wallpaper2.readfrombuffer(buf)
0263         self._bufferendoffset=buf.getcurrentoffset()
0264 
0265 
0266     def __getfield_info(self):
0267         return self.__field_info.getvalue()
0268 
0269     def __setfield_info(self, value):
0270         if isinstance(value,UINT):
0271             self.__field_info=value
0272         else:
0273             self.__field_info=UINT(value,**{'sizeinbytes': 2})
0274 
0275     def __delfield_info(self): del self.__field_info
0276 
0277     info=property(__getfield_info, __setfield_info, __delfield_info, None)
0278 
0279     def __getfield_info2(self):
0280         return self.__field_info2.getvalue()
0281 
0282     def __setfield_info2(self, value):
0283         if isinstance(value,UINT):
0284             self.__field_info2=value
0285         else:
0286             self.__field_info2=UINT(value,**{'sizeinbytes': 2})
0287 
0288     def __delfield_info2(self): del self.__field_info2
0289 
0290     info2=property(__getfield_info2, __setfield_info2, __delfield_info2, None)
0291 
0292     def __getfield_name(self):
0293         return self.__field_name.getvalue()
0294 
0295     def __setfield_name(self, value):
0296         if isinstance(value,USTRING):
0297             self.__field_name=value
0298         else:
0299             self.__field_name=USTRING(value,**{ 'terminator': None,                    'encoding': ENCODING,                    'pascal': True })
0300 
0301     def __delfield_name(self): del self.__field_name
0302 
0303     name=property(__getfield_name, __setfield_name, __delfield_name, None)
0304 
0305     def __getfield_email(self):
0306         return self.__field_email.getvalue()
0307 
0308     def __setfield_email(self, value):
0309         if isinstance(value,USTRING):
0310             self.__field_email=value
0311         else:
0312             self.__field_email=USTRING(value,**{ 'terminator': None,                    'encoding': ENCODING,                    'pascal': True })
0313 
0314     def __delfield_email(self): del self.__field_email
0315 
0316     email=property(__getfield_email, __setfield_email, __delfield_email, None)
0317 
0318     def __getfield_email2(self):
0319         return self.__field_email2.getvalue()
0320 
0321     def __setfield_email2(self, value):
0322         if isinstance(value,USTRING):
0323             self.__field_email2=value
0324         else:
0325             self.__field_email2=USTRING(value,**{ 'terminator': None,                    'encoding': ENCODING,                   'pascal': True })
0326 
0327     def __delfield_email2(self): del self.__field_email2
0328 
0329     email2=property(__getfield_email2, __setfield_email2, __delfield_email2, None)
0330 
0331     def __getfield_home(self):
0332         return self.__field_home.getvalue()
0333 
0334     def __setfield_home(self, value):
0335         if isinstance(value,NumberEntry):
0336             self.__field_home=value
0337         else:
0338             self.__field_home=NumberEntry(value,)
0339 
0340     def __delfield_home(self): del self.__field_home
0341 
0342     home=property(__getfield_home, __setfield_home, __delfield_home, None)
0343 
0344     def __getfield_work(self):
0345         return self.__field_work.getvalue()
0346 
0347     def __setfield_work(self, value):
0348         if isinstance(value,NumberEntry):
0349             self.__field_work=value
0350         else:
0351             self.__field_work=NumberEntry(value,)
0352 
0353     def __delfield_work(self): del self.__field_work
0354 
0355     work=property(__getfield_work, __setfield_work, __delfield_work, None)
0356 
0357     def __getfield_cell(self):
0358         return self.__field_cell.getvalue()
0359 
0360     def __setfield_cell(self, value):
0361         if isinstance(value,NumberEntry):
0362             self.__field_cell=value
0363         else:
0364             self.__field_cell=NumberEntry(value,)
0365 
0366     def __delfield_cell(self): del self.__field_cell
0367 
0368     cell=property(__getfield_cell, __setfield_cell, __delfield_cell, None)
0369 
0370     def __getfield_fax(self):
0371         return self.__field_fax.getvalue()
0372 
0373     def __setfield_fax(self, value):
0374         if isinstance(value,NumberEntry):
0375             self.__field_fax=value
0376         else:
0377             self.__field_fax=NumberEntry(value,)
0378 
0379     def __delfield_fax(self): del self.__field_fax
0380 
0381     fax=property(__getfield_fax, __setfield_fax, __delfield_fax, None)
0382 
0383     def __getfield_cell2(self):
0384         return self.__field_cell2.getvalue()
0385 
0386     def __setfield_cell2(self, value):
0387         if isinstance(value,NumberEntry):
0388             self.__field_cell2=value
0389         else:
0390             self.__field_cell2=NumberEntry(value,)
0391 
0392     def __delfield_cell2(self): del self.__field_cell2
0393 
0394     cell2=property(__getfield_cell2, __setfield_cell2, __delfield_cell2, None)
0395 
0396     def __getfield_note(self):
0397         return self.__field_note.getvalue()
0398 
0399     def __setfield_note(self, value):
0400         if isinstance(value,STRING):
0401             self.__field_note=value
0402         else:
0403             self.__field_note=STRING(value,**{ 'terminator': None,                   'pascal': True })
0404 
0405     def __delfield_note(self): del self.__field_note
0406 
0407     note=property(__getfield_note, __setfield_note, __delfield_note, None)
0408 
0409     def __getfield_datetime(self):
0410         return self.__field_datetime.getvalue()
0411 
0412     def __setfield_datetime(self, value):
0413         if isinstance(value,DateTime):
0414             self.__field_datetime=value
0415         else:
0416             self.__field_datetime=DateTime(value,**{'sizeinbytes': 4})
0417 
0418     def __delfield_datetime(self): del self.__field_datetime
0419 
0420     datetime=property(__getfield_datetime, __setfield_datetime, __delfield_datetime, None)
0421 
0422     def __getfield_group(self):
0423         return self.__field_group.getvalue()
0424 
0425     def __setfield_group(self, value):
0426         if isinstance(value,UINT):
0427             self.__field_group=value
0428         else:
0429             self.__field_group=UINT(value,**{'sizeinbytes': 1})
0430 
0431     def __delfield_group(self): del self.__field_group
0432 
0433     group=property(__getfield_group, __setfield_group, __delfield_group, None)
0434 
0435     def __getfield_wallpaper(self):
0436         return self.__field_wallpaper.getvalue()
0437 
0438     def __setfield_wallpaper(self, value):
0439         if isinstance(value,STRING):
0440             self.__field_wallpaper=value
0441         else:
0442             self.__field_wallpaper=STRING(value,**{ 'terminator': None,                   'pascal': True })
0443 
0444     def __delfield_wallpaper(self): del self.__field_wallpaper
0445 
0446     wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None)
0447 
0448     def __getfield_wallpaper_range(self):
0449         return self.__field_wallpaper_range.getvalue()
0450 
0451     def __setfield_wallpaper_range(self, value):
0452         if isinstance(value,UINT):
0453             self.__field_wallpaper_range=value
0454         else:
0455             self.__field_wallpaper_range=UINT(value,**{'sizeinbytes': 4})
0456 
0457     def __delfield_wallpaper_range(self): del self.__field_wallpaper_range
0458 
0459     wallpaper_range=property(__getfield_wallpaper_range, __setfield_wallpaper_range, __delfield_wallpaper_range, None)
0460 
0461     def __getfield_ringtone(self):
0462         return self.__field_ringtone.getvalue()
0463 
0464     def __setfield_ringtone(self, value):
0465         if isinstance(value,STRING):
0466             self.__field_ringtone=value
0467         else:
0468             self.__field_ringtone=STRING(value,**{ 'terminator': None,                   'pascal': True })
0469 
0470     def __delfield_ringtone(self): del self.__field_ringtone
0471 
0472     ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None)
0473 
0474     def __getfield_wallpaper2(self):
0475         return self.__field_wallpaper2.getvalue()
0476 
0477     def __setfield_wallpaper2(self, value):
0478         if isinstance(value,STRING):
0479             self.__field_wallpaper2=value
0480         else:
0481             self.__field_wallpaper2=STRING(value,**{ 'terminator': None,                   'pascal': True })
0482 
0483     def __delfield_wallpaper2(self): del self.__field_wallpaper2
0484 
0485     wallpaper2=property(__getfield_wallpaper2, __setfield_wallpaper2, __delfield_wallpaper2, None)
0486 
0487     def iscontainer(self):
0488         return True
0489 
0490     def containerelements(self):
0491         yield ('info', self.__field_info, None)
0492         yield ('info2', self.__field_info2, None)
0493         if self.info & PB_FLG_NAME:
0494             yield ('name', self.__field_name, None)
0495         if self.info & PB_FLG_EMAIL:
0496             yield ('email', self.__field_email, None)
0497         if self.info & PB_FLG_EMAIL2:
0498             yield ('email2', self.__field_email2, None)
0499         if self.info & PB_FLG_HOME:
0500             yield ('home', self.__field_home, None)
0501         if self.info & PB_FLG_WORK:
0502             yield ('work', self.__field_work, None)
0503         if self.info & PB_FLG_CELL:
0504             yield ('cell', self.__field_cell, None)
0505         if self.info & PB_FLG_FAX:
0506             yield ('fax', self.__field_fax, None)
0507         if self.info & PB_FLG_CELL2:
0508             yield ('cell2', self.__field_cell2, None)
0509         if self.info & PB_FLG_NOTE:
0510             yield ('note', self.__field_note, None)
0511         if self.info & PB_FLG_DATE:
0512             yield ('datetime', self.__field_datetime, None)
0513         if self.info & PB_FLG_GROUP:
0514             yield ('group', self.__field_group, None)
0515         if self.info & PB_FLG_WP:
0516             yield ('wallpaper', self.__field_wallpaper, None)
0517             yield ('wallpaper_range', self.__field_wallpaper_range, None)
0518         if self.info2 & PB_FLG2_RINGTONE:
0519             yield ('ringtone', self.__field_ringtone, None)
0520         if self.info2 & PB_FLG2_WP:
0521             yield ('wallpaper2', self.__field_wallpaper2, None)
0522 
0523 
0524 
0525 
0526 class LenEntry(BaseProtogenClass):
0527     __fields=['itemlen']
0528 
0529     def __init__(self, *args, **kwargs):
0530         dict={}
0531         # What was supplied to this function
0532         dict.update(kwargs)
0533         # Parent constructor
0534         super(LenEntry,self).__init__(**dict)
0535         if self.__class__ is LenEntry:
0536             self._update(args,dict)
0537 
0538 
0539     def getfields(self):
0540         return self.__fields
0541 
0542 
0543     def _update(self, args, kwargs):
0544         super(LenEntry,self)._update(args,kwargs)
0545         keys=kwargs.keys()
0546         for key in keys:
0547             if key in self.__fields:
0548                 setattr(self, key, kwargs[key])
0549                 del kwargs[key]
0550         # Were any unrecognized kwargs passed in?
0551         if __debug__:
0552             self._complainaboutunusedargs(LenEntry,kwargs)
0553         if len(args):
0554             dict2={'sizeinbytes': 2,  'default': 0 }
0555             dict2.update(kwargs)
0556             kwargs=dict2
0557             self.__field_itemlen=UINT(*args,**dict2)
0558         # Make all P fields that haven't already been constructed
0559 
0560 
0561     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0562         'Writes this packet to the supplied buffer'
0563         self._bufferstartoffset=buf.getcurrentoffset()
0564         try: self.__field_itemlen
0565         except:
0566             self.__field_itemlen=UINT(**{'sizeinbytes': 2,  'default': 0 })
0567         self.__field_itemlen.writetobuffer(buf)
0568         self._bufferendoffset=buf.getcurrentoffset()
0569         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0570 
0571 
0572     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0573         'Reads this packet from the supplied buffer'
0574         self._bufferstartoffset=buf.getcurrentoffset()
0575         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0576         self.__field_itemlen=UINT(**{'sizeinbytes': 2,  'default': 0 })
0577         self.__field_itemlen.readfrombuffer(buf)
0578         self._bufferendoffset=buf.getcurrentoffset()
0579 
0580 
0581     def __getfield_itemlen(self):
0582         try: self.__field_itemlen
0583         except:
0584             self.__field_itemlen=UINT(**{'sizeinbytes': 2,  'default': 0 })
0585         return self.__field_itemlen.getvalue()
0586 
0587     def __setfield_itemlen(self, value):
0588         if isinstance(value,UINT):
0589             self.__field_itemlen=value
0590         else:
0591             self.__field_itemlen=UINT(value,**{'sizeinbytes': 2,  'default': 0 })
0592 
0593     def __delfield_itemlen(self): del self.__field_itemlen
0594 
0595     itemlen=property(__getfield_itemlen, __setfield_itemlen, __delfield_itemlen, None)
0596 
0597     def iscontainer(self):
0598         return True
0599 
0600     def containerelements(self):
0601         yield ('itemlen', self.__field_itemlen, None)
0602 
0603 
0604 
0605 
0606 class PBFile(BaseProtogenClass):
0607     __fields=['lens', 'items']
0608 
0609     def __init__(self, *args, **kwargs):
0610         dict={}
0611         # What was supplied to this function
0612         dict.update(kwargs)
0613         # Parent constructor
0614         super(PBFile,self).__init__(**dict)
0615         if self.__class__ is PBFile:
0616             self._update(args,dict)
0617 
0618 
0619     def getfields(self):
0620         return self.__fields
0621 
0622 
0623     def _update(self, args, kwargs):
0624         super(PBFile,self)._update(args,kwargs)
0625         keys=kwargs.keys()
0626         for key in keys:
0627             if key in self.__fields:
0628                 setattr(self, key, kwargs[key])
0629                 del kwargs[key]
0630         # Were any unrecognized kwargs passed in?
0631         if __debug__:
0632             self._complainaboutunusedargs(PBFile,kwargs)
0633         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0634         # Make all P fields that haven't already been constructed
0635 
0636 
0637     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0638         'Writes this packet to the supplied buffer'
0639         self._bufferstartoffset=buf.getcurrentoffset()
0640         try: self.__field_lens
0641         except:
0642             self.__field_lens=LIST(**{ 'elementclass': LenEntry,             'length': 8,             'createdefault': True })
0643         self.__field_lens.writetobuffer(buf)
0644         try: self.__field_items
0645         except:
0646             self.__field_items=LIST(**{ 'elementclass': PBEntry })
0647         self.__field_items.writetobuffer(buf)
0648         self._bufferendoffset=buf.getcurrentoffset()
0649         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0650 
0651 
0652     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0653         'Reads this packet from the supplied buffer'
0654         self._bufferstartoffset=buf.getcurrentoffset()
0655         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0656         self.__field_lens=LIST(**{ 'elementclass': LenEntry,             'length': 8,             'createdefault': True })
0657         self.__field_lens.readfrombuffer(buf)
0658         self.__field_items=LIST(**{ 'elementclass': PBEntry })
0659         self.__field_items.readfrombuffer(buf)
0660         self._bufferendoffset=buf.getcurrentoffset()
0661 
0662 
0663     def __getfield_lens(self):
0664         try: self.__field_lens
0665         except:
0666             self.__field_lens=LIST(**{ 'elementclass': LenEntry,             'length': 8,             'createdefault': True })
0667         return self.__field_lens.getvalue()
0668 
0669     def __setfield_lens(self, value):
0670         if isinstance(value,LIST):
0671             self.__field_lens=value
0672         else:
0673             self.__field_lens=LIST(value,**{ 'elementclass': LenEntry,             'length': 8,             'createdefault': True })
0674 
0675     def __delfield_lens(self): del self.__field_lens
0676 
0677     lens=property(__getfield_lens, __setfield_lens, __delfield_lens, None)
0678 
0679     def __getfield_items(self):
0680         try: self.__field_items
0681         except:
0682             self.__field_items=LIST(**{ 'elementclass': PBEntry })
0683         return self.__field_items.getvalue()
0684 
0685     def __setfield_items(self, value):
0686         if isinstance(value,LIST):
0687             self.__field_items=value
0688         else:
0689             self.__field_items=LIST(value,**{ 'elementclass': PBEntry })
0690 
0691     def __delfield_items(self): del self.__field_items
0692 
0693     items=property(__getfield_items, __setfield_items, __delfield_items, None)
0694 
0695     def iscontainer(self):
0696         return True
0697 
0698     def containerelements(self):
0699         yield ('lens', self.__field_lens, None)
0700         yield ('items', self.__field_items, None)
0701 
0702 
0703 
0704 
0705 class PBFileHeader(BaseProtogenClass):
0706     __fields=['lens']
0707 
0708     def __init__(self, *args, **kwargs):
0709         dict={}
0710         # What was supplied to this function
0711         dict.update(kwargs)
0712         # Parent constructor
0713         super(PBFileHeader,self).__init__(**dict)
0714         if self.__class__ is PBFileHeader:
0715             self._update(args,dict)
0716 
0717 
0718     def getfields(self):
0719         return self.__fields
0720 
0721 
0722     def _update(self, args, kwargs):
0723         super(PBFileHeader,self)._update(args,kwargs)
0724         keys=kwargs.keys()
0725         for key in keys:
0726             if key in self.__fields:
0727                 setattr(self, key, kwargs[key])
0728                 del kwargs[key]
0729         # Were any unrecognized kwargs passed in?
0730         if __debug__:
0731             self._complainaboutunusedargs(PBFileHeader,kwargs)
0732         if len(args):
0733             dict2={ 'elementclass': LenEntry,             'length': 8,             'createdefault': True }
0734             dict2.update(kwargs)
0735             kwargs=dict2
0736             self.__field_lens=LIST(*args,**dict2)
0737         # Make all P fields that haven't already been constructed
0738 
0739 
0740     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0741         'Writes this packet to the supplied buffer'
0742         self._bufferstartoffset=buf.getcurrentoffset()
0743         try: self.__field_lens
0744         except:
0745             self.__field_lens=LIST(**{ 'elementclass': LenEntry,             'length': 8,             'createdefault': True })
0746         self.__field_lens.writetobuffer(buf)
0747         self._bufferendoffset=buf.getcurrentoffset()
0748         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0749 
0750 
0751     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0752         'Reads this packet from the supplied buffer'
0753         self._bufferstartoffset=buf.getcurrentoffset()
0754         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0755         self.__field_lens=LIST(**{ 'elementclass': LenEntry,             'length': 8,             'createdefault': True })
0756         self.__field_lens.readfrombuffer(buf)
0757         self._bufferendoffset=buf.getcurrentoffset()
0758 
0759 
0760     def __getfield_lens(self):
0761         try: self.__field_lens
0762         except:
0763             self.__field_lens=LIST(**{ 'elementclass': LenEntry,             'length': 8,             'createdefault': True })
0764         return self.__field_lens.getvalue()
0765 
0766     def __setfield_lens(self, value):
0767         if isinstance(value,LIST):
0768             self.__field_lens=value
0769         else:
0770             self.__field_lens=LIST(value,**{ 'elementclass': LenEntry,             'length': 8,             'createdefault': True })
0771 
0772     def __delfield_lens(self): del self.__field_lens
0773 
0774     lens=property(__getfield_lens, __setfield_lens, __delfield_lens, None)
0775 
0776     def iscontainer(self):
0777         return True
0778 
0779     def containerelements(self):
0780         yield ('lens', self.__field_lens, None)
0781 
0782 
0783 
0784 
0785 class ss_number_entry(BaseProtogenClass):
0786     __fields=['number', 'speeddial', 'primary', 'zero', 'ringtone']
0787 
0788     def __init__(self, *args, **kwargs):
0789         dict={}
0790         # What was supplied to this function
0791         dict.update(kwargs)
0792         # Parent constructor
0793         super(ss_number_entry,self).__init__(**dict)
0794         if self.__class__ is ss_number_entry:
0795             self._update(args,dict)
0796 
0797 
0798     def getfields(self):
0799         return self.__fields
0800 
0801 
0802     def _update(self, args, kwargs):
0803         super(ss_number_entry,self)._update(args,kwargs)
0804         keys=kwargs.keys()
0805         for key in keys:
0806             if key in self.__fields:
0807                 setattr(self, key, kwargs[key])
0808                 del kwargs[key]
0809         # Were any unrecognized kwargs passed in?
0810         if __debug__:
0811             self._complainaboutunusedargs(ss_number_entry,kwargs)
0812         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0813         # Make all P fields that haven't already been constructed
0814 
0815 
0816     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0817         'Writes this packet to the supplied buffer'
0818         self._bufferstartoffset=buf.getcurrentoffset()
0819         try: self.__field_number
0820         except:
0821             self.__field_number=STRING(**{ 'terminator': 0,               'default': '',               'maxsizeinbytes': PB_MAX_NUMBER_LEN,               'raiseontruncate': False })
0822         self.__field_number.writetobuffer(buf)
0823         try: self.__field_speeddial
0824         except:
0825             self.__field_speeddial=UINT(**{'sizeinbytes': 2,  'default': 0 })
0826         self.__field_speeddial.writetobuffer(buf)
0827         try: self.__field_primary
0828         except:
0829             self.__field_primary=UINT(**{'sizeinbytes': 1,  'default': 0 })
0830         self.__field_primary.writetobuffer(buf)
0831         try: self.__field_zero
0832         except:
0833             self.__field_zero=STRING(**{'sizeinbytes': 8,  'pad': 0,               'default': '' })
0834         self.__field_zero.writetobuffer(buf)
0835         try: self.__field_ringtone
0836         except:
0837             self.__field_ringtone=STRING(**{ 'terminator': 0,               'default': '' })
0838         self.__field_ringtone.writetobuffer(buf)
0839         self._bufferendoffset=buf.getcurrentoffset()
0840         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0841 
0842 
0843     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0844         'Reads this packet from the supplied buffer'
0845         self._bufferstartoffset=buf.getcurrentoffset()
0846         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0847         self.__field_number=STRING(**{ 'terminator': 0,               'default': '',               'maxsizeinbytes': PB_MAX_NUMBER_LEN,               'raiseontruncate': False })
0848         self.__field_number.readfrombuffer(buf)
0849         self.__field_speeddial=UINT(**{'sizeinbytes': 2,  'default': 0 })
0850         self.__field_speeddial.readfrombuffer(buf)
0851         self.__field_primary=UINT(**{'sizeinbytes': 1,  'default': 0 })
0852         self.__field_primary.readfrombuffer(buf)
0853         self.__field_zero=STRING(**{'sizeinbytes': 8,  'pad': 0,               'default': '' })
0854         self.__field_zero.readfrombuffer(buf)
0855         self.__field_ringtone=STRING(**{ 'terminator': 0,               'default': '' })
0856         self.__field_ringtone.readfrombuffer(buf)
0857         self._bufferendoffset=buf.getcurrentoffset()
0858 
0859 
0860     def __getfield_number(self):
0861         try: self.__field_number
0862         except:
0863             self.__field_number=STRING(**{ 'terminator': 0,               'default': '',               'maxsizeinbytes': PB_MAX_NUMBER_LEN,               'raiseontruncate': False })
0864         return self.__field_number.getvalue()
0865 
0866     def __setfield_number(self, value):
0867         if isinstance(value,STRING):
0868             self.__field_number=value
0869         else:
0870             self.__field_number=STRING(value,**{ 'terminator': 0,               'default': '',               'maxsizeinbytes': PB_MAX_NUMBER_LEN,               'raiseontruncate': False })
0871 
0872     def __delfield_number(self): del self.__field_number
0873 
0874     number=property(__getfield_number, __setfield_number, __delfield_number, None)
0875 
0876     def __getfield_speeddial(self):
0877         try: self.__field_speeddial
0878         except:
0879             self.__field_speeddial=UINT(**{'sizeinbytes': 2,  'default': 0 })
0880         return self.__field_speeddial.getvalue()
0881 
0882     def __setfield_speeddial(self, value):
0883         if isinstance(value,UINT):
0884             self.__field_speeddial=value
0885         else:
0886             self.__field_speeddial=UINT(value,**{'sizeinbytes': 2,  'default': 0 })
0887 
0888     def __delfield_speeddial(self): del self.__field_speeddial
0889 
0890     speeddial=property(__getfield_speeddial, __setfield_speeddial, __delfield_speeddial, None)
0891 
0892     def __getfield_primary(self):
0893         try: self.__field_primary
0894         except:
0895             self.__field_primary=UINT(**{'sizeinbytes': 1,  'default': 0 })
0896         return self.__field_primary.getvalue()
0897 
0898     def __setfield_primary(self, value):
0899         if isinstance(value,UINT):
0900             self.__field_primary=value
0901         else:
0902             self.__field_primary=UINT(value,**{'sizeinbytes': 1,  'default': 0 })
0903 
0904     def __delfield_primary(self): del self.__field_primary
0905 
0906     primary=property(__getfield_primary, __setfield_primary, __delfield_primary, None)
0907 
0908     def __getfield_zero(self):
0909         try: self.__field_zero
0910         except:
0911             self.__field_zero=STRING(**{'sizeinbytes': 8,  'pad': 0,               'default': '' })
0912         return self.__field_zero.getvalue()
0913 
0914     def __setfield_zero(self, value):
0915         if isinstance(value,STRING):
0916             self.__field_zero=value
0917         else:
0918             self.__field_zero=STRING(value,**{'sizeinbytes': 8,  'pad': 0,               'default': '' })
0919 
0920     def __delfield_zero(self): del self.__field_zero
0921 
0922     zero=property(__getfield_zero, __setfield_zero, __delfield_zero, None)
0923 
0924     def __getfield_ringtone(self):
0925         try: self.__field_ringtone
0926         except:
0927             self.__field_ringtone=STRING(**{ 'terminator': 0,               'default': '' })
0928         return self.__field_ringtone.getvalue()
0929 
0930     def __setfield_ringtone(self, value):
0931         if isinstance(value,STRING):
0932             self.__field_ringtone=value
0933         else:
0934             self.__field_ringtone=STRING(value,**{ 'terminator': 0,               'default': '' })
0935 
0936     def __delfield_ringtone(self): del self.__field_ringtone
0937 
0938     ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None)
0939 
0940     def iscontainer(self):
0941         return True
0942 
0943     def containerelements(self):
0944         yield ('number', self.__field_number, None)
0945         yield ('speeddial', self.__field_speeddial, None)
0946         yield ('primary', self.__field_primary, None)
0947         yield ('zero', self.__field_zero, None)
0948         yield ('ringtone', self.__field_ringtone, None)
0949 
0950 
0951 
0952 
0953 class ss_pb_entry(BaseProtogenClass):
0954     __fields=['name', 'email', 'email2', 'zero1', 'note', 'zero5', 'wallpaper', 'zero2', 'home', 'work', 'cell', 'dummy', 'fax', 'cell2', 'zero3', 'group', 'zero4']
0955 
0956     def __init__(self, *args, **kwargs):
0957         dict={}
0958         # What was supplied to this function
0959         dict.update(kwargs)
0960         # Parent constructor
0961         super(ss_pb_entry,self).__init__(**dict)
0962         if self.__class__ is ss_pb_entry:
0963             self._update(args,dict)
0964 
0965 
0966     def getfields(self):
0967         return self.__fields
0968 
0969 
0970     def _update(self, args, kwargs):
0971         super(ss_pb_entry,self)._update(args,kwargs)
0972         keys=kwargs.keys()
0973         for key in keys:
0974             if key in self.__fields:
0975                 setattr(self, key, kwargs[key])
0976                 del kwargs[key]
0977         # Were any unrecognized kwargs passed in?
0978         if __debug__:
0979             self._complainaboutunusedargs(ss_pb_entry,kwargs)
0980         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0981         # Make all P fields that haven't already been constructed
0982 
0983 
0984     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0985         'Writes this packet to the supplied buffer'
0986         self._bufferstartoffset=buf.getcurrentoffset()
0987         self.__field_name.writetobuffer(buf)
0988         try: self.__field_email
0989         except:
0990             self.__field_email=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'default': '',                'maxsizeinbytes': PB_MAX_EMAIL_LEN,                'raiseontruncate': False })
0991         self.__field_email.writetobuffer(buf)
0992         try: self.__field_email2
0993         except:
0994             self.__field_email2=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'default': '',                'maxsizeinbytes': PB_MAX_EMAIL_LEN,                'raiseontruncate': False })
0995         self.__field_email2.writetobuffer(buf)
0996         try: self.__field_zero1
0997         except:
0998             self.__field_zero1=UINT(**{'sizeinbytes': 2,  'default': 0 })
0999         self.__field_zero1.writetobuffer(buf)
1000         try: self.__field_note
1001         except:
1002             self.__field_note=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'maxsizeinbytes': PB_MAX_NOTE_LEN,                'raiseontruncate': False,                'default': '' })
1003         self.__field_note.writetobuffer(buf)
1004         try: self.__field_zero5
1005         except:
1006             self.__field_zero5=UINT(**{'sizeinbytes': 1,  'default': 0 })
1007         self.__field_zero5.writetobuffer(buf)
1008         try: self.__field_wallpaper
1009         except:
1010             self.__field_wallpaper=STRING(**{ 'terminator': 0,               'default': '' })
1011         self.__field_wallpaper.writetobuffer(buf)
1012         try: self.__field_zero2
1013         except:
1014             self.__field_zero2=UINT(**{'sizeinbytes': 1,  'default': 0 })
1015         self.__field_zero2.writetobuffer(buf)
1016         try: self.__field_home
1017         except:
1018             self.__field_home=ss_number_entry()
1019         self.__field_home.writetobuffer(buf)
1020         try: self.__field_work
1021         except:
1022             self.__field_work=ss_number_entry()
1023         self.__field_work.writetobuffer(buf)
1024         try: self.__field_cell
1025         except:
1026             self.__field_cell=ss_number_entry()
1027         self.__field_cell.writetobuffer(buf)
1028         try: self.__field_dummy
1029         except:
1030             self.__field_dummy=ss_number_entry()
1031         self.__field_dummy.writetobuffer(buf)
1032         try: self.__field_fax
1033         except:
1034             self.__field_fax=ss_number_entry()
1035         self.__field_fax.writetobuffer(buf)
1036         try: self.__field_cell2
1037         except:
1038             self.__field_cell2=ss_number_entry()
1039         self.__field_cell2.writetobuffer(buf)
1040         try: self.__field_zero3
1041         except:
1042             self.__field_zero3=UINT(**{'sizeinbytes': 4,  'default': 0 })
1043         self.__field_zero3.writetobuffer(buf)
1044         try: self.__field_group
1045         except:
1046             self.__field_group=UINT(**{'sizeinbytes': 1,  'default': 0 })
1047         self.__field_group.writetobuffer(buf)
1048         try: self.__field_zero4
1049         except:
1050             self.__field_zero4=UINT(**{'sizeinbytes': 2,  'default': 0 })
1051         self.__field_zero4.writetobuffer(buf)
1052         self._bufferendoffset=buf.getcurrentoffset()
1053         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1054 
1055 
1056     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1057         'Reads this packet from the supplied buffer'
1058         self._bufferstartoffset=buf.getcurrentoffset()
1059         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1060         self.__field_name=USTRING(**{ 'terminator': 0,                'maxsizeinbytes': PB_MAX_NAME_LEN,                'encoding': ENCODING,                'raiseontruncate': False })
1061         self.__field_name.readfrombuffer(buf)
1062         self.__field_email=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'default': '',                'maxsizeinbytes': PB_MAX_EMAIL_LEN,                'raiseontruncate': False })
1063         self.__field_email.readfrombuffer(buf)
1064         self.__field_email2=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'default': '',                'maxsizeinbytes': PB_MAX_EMAIL_LEN,                'raiseontruncate': False })
1065         self.__field_email2.readfrombuffer(buf)
1066         self.__field_zero1=UINT(**{'sizeinbytes': 2,  'default': 0 })
1067         self.__field_zero1.readfrombuffer(buf)
1068         self.__field_note=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'maxsizeinbytes': PB_MAX_NOTE_LEN,                'raiseontruncate': False,                'default': '' })
1069         self.__field_note.readfrombuffer(buf)
1070         self.__field_zero5=UINT(**{'sizeinbytes': 1,  'default': 0 })
1071         self.__field_zero5.readfrombuffer(buf)
1072         self.__field_wallpaper=STRING(**{ 'terminator': 0,               'default': '' })
1073         self.__field_wallpaper.readfrombuffer(buf)
1074         self.__field_zero2=UINT(**{'sizeinbytes': 1,  'default': 0 })
1075         self.__field_zero2.readfrombuffer(buf)
1076         self.__field_home=ss_number_entry()
1077         self.__field_home.readfrombuffer(buf)
1078         self.__field_work=ss_number_entry()
1079         self.__field_work.readfrombuffer(buf)
1080         self.__field_cell=ss_number_entry()
1081         self.__field_cell.readfrombuffer(buf)
1082         self.__field_dummy=ss_number_entry()
1083         self.__field_dummy.readfrombuffer(buf)
1084         self.__field_fax=ss_number_entry()
1085         self.__field_fax.readfrombuffer(buf)
1086         self.__field_cell2=ss_number_entry()
1087         self.__field_cell2.readfrombuffer(buf)
1088         self.__field_zero3=UINT(**{'sizeinbytes': 4,  'default': 0 })
1089         self.__field_zero3.readfrombuffer(buf)
1090         self.__field_group=UINT(**{'sizeinbytes': 1,  'default': 0 })
1091         self.__field_group.readfrombuffer(buf)
1092         self.__field_zero4=UINT(**{'sizeinbytes': 2,  'default': 0 })
1093         self.__field_zero4.readfrombuffer(buf)
1094         self._bufferendoffset=buf.getcurrentoffset()
1095 
1096 
1097     def __getfield_name(self):
1098         return self.__field_name.getvalue()
1099 
1100     def __setfield_name(self, value):
1101         if isinstance(value,USTRING):
1102             self.__field_name=value
1103         else:
1104             self.__field_name=USTRING(value,**{ 'terminator': 0,                'maxsizeinbytes': PB_MAX_NAME_LEN,                'encoding': ENCODING,                'raiseontruncate': False })
1105 
1106     def __delfield_name(self): del self.__field_name
1107 
1108     name=property(__getfield_name, __setfield_name, __delfield_name, None)
1109 
1110     def __getfield_email(self):
1111         try: self.__field_email
1112         except:
1113             self.__field_email=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'default': '',                'maxsizeinbytes': PB_MAX_EMAIL_LEN,                'raiseontruncate': False })
1114         return self.__field_email.getvalue()
1115 
1116     def __setfield_email(self, value):
1117         if isinstance(value,USTRING):
1118             self.__field_email=value
1119         else:
1120             self.__field_email=USTRING(value,**{ 'terminator': 0,                'encoding': ENCODING,                'default': '',                'maxsizeinbytes': PB_MAX_EMAIL_LEN,                'raiseontruncate': False })
1121 
1122     def __delfield_email(self): del self.__field_email
1123 
1124     email=property(__getfield_email, __setfield_email, __delfield_email, None)
1125 
1126     def __getfield_email2(self):
1127         try: self.__field_email2
1128         except:
1129             self.__field_email2=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'default': '',                'maxsizeinbytes': PB_MAX_EMAIL_LEN,                'raiseontruncate': False })
1130         return self.__field_email2.getvalue()
1131 
1132     def __setfield_email2(self, value):
1133         if isinstance(value,USTRING):
1134             self.__field_email2=value
1135         else:
1136             self.__field_email2=USTRING(value,**{ 'terminator': 0,                'encoding': ENCODING,                'default': '',                'maxsizeinbytes': PB_MAX_EMAIL_LEN,                'raiseontruncate': False })
1137 
1138     def __delfield_email2(self): del self.__field_email2
1139 
1140     email2=property(__getfield_email2, __setfield_email2, __delfield_email2, None)
1141 
1142     def __getfield_zero1(self):
1143         try: self.__field_zero1
1144         except:
1145             self.__field_zero1=UINT(**{'sizeinbytes': 2,  'default': 0 })
1146         return self.__field_zero1.getvalue()
1147 
1148     def __setfield_zero1(self, value):
1149         if isinstance(value,UINT):
1150             self.__field_zero1=value
1151         else:
1152             self.__field_zero1=UINT(value,**{'sizeinbytes': 2,  'default': 0 })
1153 
1154     def __delfield_zero1(self): del self.__field_zero1
1155 
1156     zero1=property(__getfield_zero1, __setfield_zero1, __delfield_zero1, None)
1157 
1158     def __getfield_note(self):
1159         try: self.__field_note
1160         except:
1161             self.__field_note=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'maxsizeinbytes': PB_MAX_NOTE_LEN,                'raiseontruncate': False,                'default': '' })
1162         return self.__field_note.getvalue()
1163 
1164     def __setfield_note(self, value):
1165         if isinstance(value,USTRING):
1166             self.__field_note=value
1167         else:
1168             self.__field_note=USTRING(value,**{ 'terminator': 0,                'encoding': ENCODING,                'maxsizeinbytes': PB_MAX_NOTE_LEN,                'raiseontruncate': False,                'default': '' })
1169 
1170     def __delfield_note(self): del self.__field_note
1171 
1172     note=property(__getfield_note, __setfield_note, __delfield_note, None)
1173 
1174     def __getfield_zero5(self):
1175         try: self.__field_zero5
1176         except:
1177             self.__field_zero5=UINT(**{'sizeinbytes': 1,  'default': 0 })
1178         return self.__field_zero5.getvalue()
1179 
1180     def __setfield_zero5(self, value):
1181         if isinstance(value,UINT):
1182             self.__field_zero5=value
1183         else:
1184             self.__field_zero5=UINT(value,**{'sizeinbytes': 1,  'default': 0 })
1185 
1186     def __delfield_zero5(self): del self.__field_zero5
1187 
1188     zero5=property(__getfield_zero5, __setfield_zero5, __delfield_zero5, None)
1189 
1190     def __getfield_wallpaper(self):
1191         try: self.__field_wallpaper
1192         except:
1193             self.__field_wallpaper=STRING(**{ 'terminator': 0,               'default': '' })
1194         return self.__field_wallpaper.getvalue()
1195 
1196     def __setfield_wallpaper(self, value):
1197         if isinstance(value,STRING):
1198             self.__field_wallpaper=value
1199         else:
1200             self.__field_wallpaper=STRING(value,**{ 'terminator': 0,               'default': '' })
1201 
1202     def __delfield_wallpaper(self): del self.__field_wallpaper
1203 
1204     wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None)
1205 
1206     def __getfield_zero2(self):
1207         try: self.__field_zero2
1208         except:
1209             self.__field_zero2=UINT(**{'sizeinbytes': 1,  'default': 0 })
1210         return self.__field_zero2.getvalue()
1211 
1212     def __setfield_zero2(self, value):
1213         if isinstance(value,UINT):
1214             self.__field_zero2=value
1215         else:
1216             self.__field_zero2=UINT(value,**{'sizeinbytes': 1,  'default': 0 })
1217 
1218     def __delfield_zero2(self): del self.__field_zero2
1219 
1220     zero2=property(__getfield_zero2, __setfield_zero2, __delfield_zero2, None)
1221 
1222     def __getfield_home(self):
1223         try: self.__field_home
1224         except:
1225             self.__field_home=ss_number_entry()
1226         return self.__field_home.getvalue()
1227 
1228     def __setfield_home(self, value):
1229         if isinstance(value,ss_number_entry):
1230             self.__field_home=value
1231         else:
1232             self.__field_home=ss_number_entry(value,)
1233 
1234     def __delfield_home(self): del self.__field_home
1235 
1236     home=property(__getfield_home, __setfield_home, __delfield_home, None)
1237 
1238     def __getfield_work(self):
1239         try: self.__field_work
1240         except:
1241             self.__field_work=ss_number_entry()
1242         return self.__field_work.getvalue()
1243 
1244     def __setfield_work(self, value):
1245         if isinstance(value,ss_number_entry):
1246             self.__field_work=value
1247         else:
1248             self.__field_work=ss_number_entry(value,)
1249 
1250     def __delfield_work(self): del self.__field_work
1251 
1252     work=property(__getfield_work, __setfield_work, __delfield_work, None)
1253 
1254     def __getfield_cell(self):
1255         try: self.__field_cell
1256         except:
1257             self.__field_cell=ss_number_entry()
1258         return self.__field_cell.getvalue()
1259 
1260     def __setfield_cell(self, value):
1261         if isinstance(value,ss_number_entry):
1262             self.__field_cell=value
1263         else:
1264             self.__field_cell=ss_number_entry(value,)
1265 
1266     def __delfield_cell(self): del self.__field_cell
1267 
1268     cell=property(__getfield_cell, __setfield_cell, __delfield_cell, None)
1269 
1270     def __getfield_dummy(self):
1271         try: self.__field_dummy
1272         except:
1273             self.__field_dummy=ss_number_entry()
1274         return self.__field_dummy.getvalue()
1275 
1276     def __setfield_dummy(self, value):
1277         if isinstance(value,ss_number_entry):
1278             self.__field_dummy=value
1279         else:
1280             self.__field_dummy=ss_number_entry(value,)
1281 
1282     def __delfield_dummy(self): del self.__field_dummy
1283 
1284     dummy=property(__getfield_dummy, __setfield_dummy, __delfield_dummy, None)
1285 
1286     def __getfield_fax(self):
1287         try: self.__field_fax
1288         except:
1289             self.__field_fax=ss_number_entry()
1290         return self.__field_fax.getvalue()
1291 
1292     def __setfield_fax(self, value):
1293         if isinstance(value,ss_number_entry):
1294             self.__field_fax=value
1295         else:
1296             self.__field_fax=ss_number_entry(value,)
1297 
1298     def __delfield_fax(self): del self.__field_fax
1299 
1300     fax=property(__getfield_fax, __setfield_fax, __delfield_fax, None)
1301 
1302     def __getfield_cell2(self):
1303         try: self.__field_cell2
1304         except:
1305             self.__field_cell2=ss_number_entry()
1306         return self.__field_cell2.getvalue()
1307 
1308     def __setfield_cell2(self, value):
1309         if isinstance(value,ss_number_entry):
1310             self.__field_cell2=value
1311         else:
1312             self.__field_cell2=ss_number_entry(value,)
1313 
1314     def __delfield_cell2(self): del self.__field_cell2
1315 
1316     cell2=property(__getfield_cell2, __setfield_cell2, __delfield_cell2, None)
1317 
1318     def __getfield_zero3(self):
1319         try: self.__field_zero3
1320         except:
1321             self.__field_zero3=UINT(**{'sizeinbytes': 4,  'default': 0 })
1322         return self.__field_zero3.getvalue()
1323 
1324     def __setfield_zero3(self, value):
1325         if isinstance(value,UINT):
1326             self.__field_zero3=value
1327         else:
1328             self.__field_zero3=UINT(value,**{'sizeinbytes': 4,  'default': 0 })
1329 
1330     def __delfield_zero3(self): del self.__field_zero3
1331 
1332     zero3=property(__getfield_zero3, __setfield_zero3, __delfield_zero3, None)
1333 
1334     def __getfield_group(self):
1335         try: self.__field_group
1336         except:
1337             self.__field_group=UINT(**{'sizeinbytes': 1,  'default': 0 })
1338         return self.__field_group.getvalue()
1339 
1340     def __setfield_group(self, value):
1341         if isinstance(value,UINT):
1342             self.__field_group=value
1343         else:
1344             self.__field_group=UINT(value,**{'sizeinbytes': 1,  'default': 0 })
1345 
1346     def __delfield_group(self): del self.__field_group
1347 
1348     group=property(__getfield_group, __setfield_group, __delfield_group, None)
1349 
1350     def __getfield_zero4(self):
1351         try: self.__field_zero4
1352         except:
1353             self.__field_zero4=UINT(**{'sizeinbytes': 2,  'default': 0 })
1354         return self.__field_zero4.getvalue()
1355 
1356     def __setfield_zero4(self, value):
1357         if isinstance(value,UINT):
1358             self.__field_zero4=value
1359         else:
1360             self.__field_zero4=UINT(value,**{'sizeinbytes': 2,  'default': 0 })
1361 
1362     def __delfield_zero4(self): del self.__field_zero4
1363 
1364     zero4=property(__getfield_zero4, __setfield_zero4, __delfield_zero4, None)
1365 
1366     def iscontainer(self):
1367         return True
1368 
1369     def containerelements(self):
1370         yield ('name', self.__field_name, None)
1371         yield ('email', self.__field_email, None)
1372         yield ('email2', self.__field_email2, None)
1373         yield ('zero1', self.__field_zero1, None)
1374         yield ('note', self.__field_note, None)
1375         yield ('zero5', self.__field_zero5, None)
1376         yield ('wallpaper', self.__field_wallpaper, None)
1377         yield ('zero2', self.__field_zero2, None)
1378         yield ('home', self.__field_home, None)
1379         yield ('work', self.__field_work, None)
1380         yield ('cell', self.__field_cell, None)
1381         yield ('dummy', self.__field_dummy, None)
1382         yield ('fax', self.__field_fax, None)
1383         yield ('cell2', self.__field_cell2, None)
1384         yield ('zero3', self.__field_zero3, None)
1385         yield ('group', self.__field_group, None)
1386         yield ('zero4', self.__field_zero4, None)
1387 
1388 
1389 
1390 
1391 class ss_pb_write_req(BaseProtogenClass):
1392     __fields=['hdr', 'zero', 'entry']
1393 
1394     def __init__(self, *args, **kwargs):
1395         dict={}
1396         # What was supplied to this function
1397         dict.update(kwargs)
1398         # Parent constructor
1399         super(ss_pb_write_req,self).__init__(**dict)
1400         if self.__class__ is ss_pb_write_req:
1401             self._update(args,dict)
1402 
1403 
1404     def getfields(self):
1405         return self.__fields
1406 
1407 
1408     def _update(self, args, kwargs):
1409         super(ss_pb_write_req,self)._update(args,kwargs)
1410         keys=kwargs.keys()
1411         for key in keys:
1412             if key in self.__fields:
1413                 setattr(self, key, kwargs[key])
1414                 del kwargs[key]
1415         # Were any unrecognized kwargs passed in?
1416         if __debug__:
1417             self._complainaboutunusedargs(ss_pb_write_req,kwargs)
1418         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1419         # Make all P fields that haven't already been constructed
1420 
1421 
1422     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1423         'Writes this packet to the supplied buffer'
1424         self._bufferstartoffset=buf.getcurrentoffset()
1425         try: self.__field_hdr
1426         except:
1427             self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_WRITE })
1428         self.__field_hdr.writetobuffer(buf)
1429         try: self.__field_zero
1430         except:
1431             self.__field_zero=UINT(**{'sizeinbytes': 1,  'default': 0 })
1432         self.__field_zero.writetobuffer(buf)
1433         self.__field_entry.writetobuffer(buf)
1434         self._bufferendoffset=buf.getcurrentoffset()
1435         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1436 
1437 
1438     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1439         'Reads this packet from the supplied buffer'
1440         self._bufferstartoffset=buf.getcurrentoffset()
1441         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1442         self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_WRITE })
1443         self.__field_hdr.readfrombuffer(buf)
1444         self.__field_zero=UINT(**{'sizeinbytes': 1,  'default': 0 })
1445         self.__field_zero.readfrombuffer(buf)
1446         self.__field_entry=ss_pb_entry()
1447         self.__field_entry.readfrombuffer(buf)
1448         self._bufferendoffset=buf.getcurrentoffset()
1449 
1450 
1451     def __getfield_hdr(self):
1452         try: self.__field_hdr
1453         except:
1454             self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_WRITE })
1455         return self.__field_hdr.getvalue()
1456 
1457     def __setfield_hdr(self, value):
1458         if isinstance(value,ss_cmd_hdr):
1459             self.__field_hdr=value
1460         else:
1461             self.__field_hdr=ss_cmd_hdr(value,**{ 'command': SS_CMD_PB_WRITE })
1462 
1463     def __delfield_hdr(self): del self.__field_hdr
1464 
1465     hdr=property(__getfield_hdr, __setfield_hdr, __delfield_hdr, None)
1466 
1467     def __getfield_zero(self):
1468         try: self.__field_zero
1469         except:
1470             self.__field_zero=UINT(**{'sizeinbytes': 1,  'default': 0 })
1471         return self.__field_zero.getvalue()
1472 
1473     def __setfield_zero(self, value):
1474         if isinstance(value,UINT):
1475             self.__field_zero=value
1476         else:
1477             self.__field_zero=UINT(value,**{'sizeinbytes': 1,  'default': 0 })
1478 
1479     def __delfield_zero(self): del self.__field_zero
1480 
1481     zero=property(__getfield_zero, __setfield_zero, __delfield_zero, None)
1482 
1483     def __getfield_entry(self):
1484         return self.__field_entry.getvalue()
1485 
1486     def __setfield_entry(self, value):
1487         if isinstance(value,ss_pb_entry):
1488             self.__field_entry=value
1489         else:
1490             self.__field_entry=ss_pb_entry(value,)
1491 
1492     def __delfield_entry(self): del self.__field_entry
1493 
1494     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
1495 
1496     def iscontainer(self):
1497         return True
1498 
1499     def containerelements(self):
1500         yield ('hdr', self.__field_hdr, None)
1501         yield ('zero', self.__field_zero, None)
1502         yield ('entry', self.__field_entry, None)
1503 
1504 
1505 
1506 
1507 class ss_pb_write_resp(BaseProtogenClass):
1508     __fields=['hdr', 'zero', 'index']
1509 
1510     def __init__(self, *args, **kwargs):
1511         dict={}
1512         # What was supplied to this function
1513         dict.update(kwargs)
1514         # Parent constructor
1515         super(ss_pb_write_resp,self).__init__(**dict)
1516         if self.__class__ is ss_pb_write_resp:
1517             self._update(args,dict)
1518 
1519 
1520     def getfields(self):
1521         return self.__fields
1522 
1523 
1524     def _update(self, args, kwargs):
1525         super(ss_pb_write_resp,self)._update(args,kwargs)
1526         keys=kwargs.keys()
1527         for key in keys:
1528             if key in self.__fields:
1529                 setattr(self, key, kwargs[key])
1530                 del kwargs[key]
1531         # Were any unrecognized kwargs passed in?
1532         if __debug__:
1533             self._complainaboutunusedargs(ss_pb_write_resp,kwargs)
1534         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1535         # Make all P fields that haven't already been constructed
1536 
1537 
1538     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1539         'Writes this packet to the supplied buffer'
1540         self._bufferstartoffset=buf.getcurrentoffset()
1541         self.__field_hdr.writetobuffer(buf)
1542         self.__field_zero.writetobuffer(buf)
1543         self.__field_index.writetobuffer(buf)
1544         self._bufferendoffset=buf.getcurrentoffset()
1545         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1546 
1547 
1548     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1549         'Reads this packet from the supplied buffer'
1550         self._bufferstartoffset=buf.getcurrentoffset()
1551         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1552         self.__field_hdr=ss_cmd_hdr()
1553         self.__field_hdr.readfrombuffer(buf)
1554         self.__field_zero=UINT(**{'sizeinbytes': 1})
1555         self.__field_zero.readfrombuffer(buf)
1556         self.__field_index=UINT(**{'sizeinbytes': 2})
1557         self.__field_index.readfrombuffer(buf)
1558         self._bufferendoffset=buf.getcurrentoffset()
1559 
1560 
1561     def __getfield_hdr(self):
1562         return self.__field_hdr.getvalue()
1563 
1564     def __setfield_hdr(self, value):
1565         if isinstance(value,ss_cmd_hdr):
1566             self.__field_hdr=value
1567         else:
1568             self.__field_hdr=ss_cmd_hdr(value,)
1569 
1570     def __delfield_hdr(self): del self.__field_hdr
1571 
1572     hdr=property(__getfield_hdr, __setfield_hdr, __delfield_hdr, None)
1573 
1574     def __getfield_zero(self):
1575         return self.__field_zero.getvalue()
1576 
1577     def __setfield_zero(self, value):
1578         if isinstance(value,UINT):
1579             self.__field_zero=value
1580         else:
1581             self.__field_zero=UINT(value,**{'sizeinbytes': 1})
1582 
1583     def __delfield_zero(self): del self.__field_zero
1584 
1585     zero=property(__getfield_zero, __setfield_zero, __delfield_zero, None)
1586 
1587     def __getfield_index(self):
1588         return self.__field_index.getvalue()
1589 
1590     def __setfield_index(self, value):
1591         if isinstance(value,UINT):
1592             self.__field_index=value
1593         else:
1594             self.__field_index=UINT(value,**{'sizeinbytes': 2})
1595 
1596     def __delfield_index(self): del self.__field_index
1597 
1598     index=property(__getfield_index, __setfield_index, __delfield_index, None)
1599 
1600     def iscontainer(self):
1601         return True
1602 
1603     def containerelements(self):
1604         yield ('hdr', self.__field_hdr, None)
1605         yield ('zero', self.__field_zero, None)
1606         yield ('index', self.__field_index, None)
1607 
1608 
1609 
1610 
1611 class CalIndexEntry(BaseProtogenClass):
1612     __fields=['index']
1613 
1614     def __init__(self, *args, **kwargs):
1615         dict={}
1616         # What was supplied to this function
1617         dict.update(kwargs)
1618         # Parent constructor
1619         super(CalIndexEntry,self).__init__(**dict)
1620         if self.__class__ is CalIndexEntry:
1621             self._update(args,dict)
1622 
1623 
1624     def getfields(self):
1625         return self.__fields
1626 
1627 
1628     def _update(self, args, kwargs):
1629         super(CalIndexEntry,self)._update(args,kwargs)
1630         keys=kwargs.keys()
1631         for key in keys:
1632             if key in self.__fields:
1633                 setattr(self, key, kwargs[key])
1634                 del kwargs[key]
1635         # Were any unrecognized kwargs passed in?
1636         if __debug__:
1637             self._complainaboutunusedargs(CalIndexEntry,kwargs)
1638         if len(args):
1639             dict2={'sizeinbytes': 2,  'default': 0 }
1640             dict2.update(kwargs)
1641             kwargs=dict2
1642             self.__field_index=UINT(*args,**dict2)
1643         # Make all P fields that haven't already been constructed
1644 
1645 
1646     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1647         'Writes this packet to the supplied buffer'
1648         self._bufferstartoffset=buf.getcurrentoffset()
1649         try: self.__field_index
1650         except:
1651             self.__field_index=UINT(**{'sizeinbytes': 2,  'default': 0 })
1652         self.__field_index.writetobuffer(buf)
1653         self._bufferendoffset=buf.getcurrentoffset()
1654         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1655 
1656 
1657     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1658         'Reads this packet from the supplied buffer'
1659         self._bufferstartoffset=buf.getcurrentoffset()
1660         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1661         self.__field_index=UINT(**{'sizeinbytes': 2,  'default': 0 })
1662         self.__field_index.readfrombuffer(buf)
1663         self._bufferendoffset=buf.getcurrentoffset()
1664 
1665 
1666     def __getfield_index(self):
1667         try: self.__field_index
1668         except:
1669             self.__field_index=UINT(**{'sizeinbytes': 2,  'default': 0 })
1670         return self.__field_index.getvalue()
1671 
1672     def __setfield_index(self, value):
1673         if isinstance(value,UINT):
1674             self.__field_index=value
1675         else:
1676             self.__field_index=UINT(value,**{'sizeinbytes': 2,  'default': 0 })
1677 
1678     def __delfield_index(self): del self.__field_index
1679 
1680     index=property(__getfield_index, __setfield_index, __delfield_index, None)
1681 
1682     def iscontainer(self):
1683         return True
1684 
1685     def containerelements(self):
1686         yield ('index', self.__field_index, None)
1687 
1688 
1689 
1690 
1691 class CalIndexFile(BaseProtogenClass):
1692     __fields=['next_index', 'zero1', 'numofevents', 'zero2', 'numofnotes', 'zero3', 'numofactiveevents', 'zero4', 'events', 'notes', 'activeevents']
1693 
1694     def __init__(self, *args, **kwargs):
1695         dict={}
1696         # What was supplied to this function
1697         dict.update(kwargs)
1698         # Parent constructor
1699         super(CalIndexFile,self).__init__(**dict)
1700         if self.__class__ is CalIndexFile:
1701             self._update(args,dict)
1702 
1703 
1704     def getfields(self):
1705         return self.__fields
1706 
1707 
1708     def _update(self, args, kwargs):
1709         super(CalIndexFile,self)._update(args,kwargs)
1710         keys=kwargs.keys()
1711         for key in keys:
1712             if key in self.__fields:
1713                 setattr(self, key, kwargs[key])
1714                 del kwargs[key]
1715         # Were any unrecognized kwargs passed in?
1716         if __debug__:
1717             self._complainaboutunusedargs(CalIndexFile,kwargs)
1718         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1719         # Make all P fields that haven't already been constructed
1720 
1721 
1722     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1723         'Writes this packet to the supplied buffer'
1724         self._bufferstartoffset=buf.getcurrentoffset()
1725         self.__field_next_index.writetobuffer(buf)
1726         try: self.__field_zero1
1727         except:
1728             self.__field_zero1=UNKNOWN(**{'sizeinbytes': 12,  'pad': 0 })
1729         self.__field_zero1.writetobuffer(buf)
1730         self.__field_numofevents.writetobuffer(buf)
1731         try: self.__field_zero2
1732         except:
1733             self.__field_zero2=UNKNOWN(**{'sizeinbytes': 6,  'pad': 0 })
1734         self.__field_zero2.writetobuffer(buf)
1735         self.__field_numofnotes.writetobuffer(buf)
1736         try: self.__field_zero3
1737         except:
1738             self.__field_zero3=UNKNOWN(**{'sizeinbytes': 6,  'pad': 0 })
1739         self.__field_zero3.writetobuffer(buf)
1740         self.__field_numofactiveevents.writetobuffer(buf)
1741         try: self.__field_zero4
1742         except:
1743             self.__field_zero4=UNKNOWN(**{'sizeinbytes': 112,  'pad': 0 })
1744         self.__field_zero4.writetobuffer(buf)
1745         try: self.__field_events
1746         except:
1747             self.__field_events=LIST(**{ 'elementclass': CalIndexEntry,             'length': 103,             'createdefault': True })
1748         self.__field_events.writetobuffer(buf)
1749         try: self.__field_notes
1750         except:
1751             self.__field_notes=LIST(**{ 'elementclass': CalIndexEntry,             'length': 35,             'createdefault': True })
1752         self.__field_notes.writetobuffer(buf)
1753         try: self.__field_activeevents
1754         except:
1755             self.__field_activeevents=LIST(**{ 'elementclass': CalIndexEntry,             'length': 319,             'createdefault': True })
1756         self.__field_activeevents.writetobuffer(buf)
1757         self._bufferendoffset=buf.getcurrentoffset()
1758         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1759 
1760 
1761     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1762         'Reads this packet from the supplied buffer'
1763         self._bufferstartoffset=buf.getcurrentoffset()
1764         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1765         self.__field_next_index=UINT(**{'sizeinbytes': 2})
1766         self.__field_next_index.readfrombuffer(buf)
1767         self.__field_zero1=UNKNOWN(**{'sizeinbytes': 12,  'pad': 0 })
1768         self.__field_zero1.readfrombuffer(buf)
1769         self.__field_numofevents=UINT(**{'sizeinbytes': 2})
1770         self.__field_numofevents.readfrombuffer(buf)
1771         self.__field_zero2=UNKNOWN(**{'sizeinbytes': 6,  'pad': 0 })
1772         self.__field_zero2.readfrombuffer(buf)
1773         self.__field_numofnotes=UINT(**{'sizeinbytes': 2})
1774         self.__field_numofnotes.readfrombuffer(buf)
1775         self.__field_zero3=UNKNOWN(**{'sizeinbytes': 6,  'pad': 0 })
1776         self.__field_zero3.readfrombuffer(buf)
1777         self.__field_numofactiveevents=UINT(**{'sizeinbytes': 2})
1778         self.__field_numofactiveevents.readfrombuffer(buf)
1779         self.__field_zero4=UNKNOWN(**{'sizeinbytes': 112,  'pad': 0 })
1780         self.__field_zero4.readfrombuffer(buf)
1781         self.__field_events=LIST(**{ 'elementclass': CalIndexEntry,             'length': 103,             'createdefault': True })
1782         self.__field_events.readfrombuffer(buf)
1783         self.__field_notes=LIST(**{ 'elementclass': CalIndexEntry,             'length': 35,             'createdefault': True })
1784         self.__field_notes.readfrombuffer(buf)
1785         self.__field_activeevents=LIST(**{ 'elementclass': CalIndexEntry,             'length': 319,             'createdefault': True })
1786         self.__field_activeevents.readfrombuffer(buf)
1787         self._bufferendoffset=buf.getcurrentoffset()
1788 
1789 
1790     def __getfield_next_index(self):
1791         return self.__field_next_index.getvalue()
1792 
1793     def __setfield_next_index(self, value):
1794         if isinstance(value,UINT):
1795             self.__field_next_index=value
1796         else:
1797             self.__field_next_index=UINT(value,**{'sizeinbytes': 2})
1798 
1799     def __delfield_next_index(self): del self.__field_next_index
1800 
1801     next_index=property(__getfield_next_index, __setfield_next_index, __delfield_next_index, None)
1802 
1803     def __getfield_zero1(self):
1804         try: self.__field_zero1
1805         except:
1806             self.__field_zero1=UNKNOWN(**{'sizeinbytes': 12,  'pad': 0 })
1807         return self.__field_zero1.getvalue()
1808 
1809     def __setfield_zero1(self, value):
1810         if isinstance(value,UNKNOWN):
1811             self.__field_zero1=value
1812         else:
1813             self.__field_zero1=UNKNOWN(value,**{'sizeinbytes': 12,  'pad': 0 })
1814 
1815     def __delfield_zero1(self): del self.__field_zero1
1816 
1817     zero1=property(__getfield_zero1, __setfield_zero1, __delfield_zero1, None)
1818 
1819     def __getfield_numofevents(self):
1820         return self.__field_numofevents.getvalue()
1821 
1822     def __setfield_numofevents(self, value):
1823         if isinstance(value,UINT):
1824             self.__field_numofevents=value
1825         else:
1826             self.__field_numofevents=UINT(value,**{'sizeinbytes': 2})
1827 
1828     def __delfield_numofevents(self): del self.__field_numofevents
1829 
1830     numofevents=property(__getfield_numofevents, __setfield_numofevents, __delfield_numofevents, None)
1831 
1832     def __getfield_zero2(self):
1833         try: self.__field_zero2
1834         except:
1835             self.__field_zero2=UNKNOWN(**{'sizeinbytes': 6,  'pad': 0 })
1836         return self.__field_zero2.getvalue()
1837 
1838     def __setfield_zero2(self, value):
1839         if isinstance(value,UNKNOWN):
1840             self.__field_zero2=value
1841         else:
1842             self.__field_zero2=UNKNOWN(value,**{'sizeinbytes': 6,  'pad': 0 })
1843 
1844     def __delfield_zero2(self): del self.__field_zero2
1845 
1846     zero2=property(__getfield_zero2, __setfield_zero2, __delfield_zero2, None)
1847 
1848     def __getfield_numofnotes(self):
1849         return self.__field_numofnotes.getvalue()
1850 
1851     def __setfield_numofnotes(self, value):
1852         if isinstance(value,UINT):
1853             self.__field_numofnotes=value
1854         else:
1855             self.__field_numofnotes=UINT(value,**{'sizeinbytes': 2})
1856 
1857     def __delfield_numofnotes(self): del self.__field_numofnotes
1858 
1859     numofnotes=property(__getfield_numofnotes, __setfield_numofnotes, __delfield_numofnotes, None)
1860 
1861     def __getfield_zero3(self):
1862         try: self.__field_zero3
1863         except:
1864             self.__field_zero3=UNKNOWN(**{'sizeinbytes': 6,  'pad': 0 })
1865         return self.__field_zero3.getvalue()
1866 
1867     def __setfield_zero3(self, value):
1868         if isinstance(value,UNKNOWN):
1869             self.__field_zero3=value
1870         else:
1871             self.__field_zero3=UNKNOWN(value,**{'sizeinbytes': 6,  'pad': 0 })
1872 
1873     def __delfield_zero3(self): del self.__field_zero3
1874 
1875     zero3=property(__getfield_zero3, __setfield_zero3, __delfield_zero3, None)
1876 
1877     def __getfield_numofactiveevents(self):
1878         return self.__field_numofactiveevents.getvalue()
1879 
1880     def __setfield_numofactiveevents(self, value):
1881         if isinstance(value,UINT):
1882             self.__field_numofactiveevents=value
1883         else:
1884             self.__field_numofactiveevents=UINT(value,**{'sizeinbytes': 2})
1885 
1886     def __delfield_numofactiveevents(self): del self.__field_numofactiveevents
1887 
1888     numofactiveevents=property(__getfield_numofactiveevents, __setfield_numofactiveevents, __delfield_numofactiveevents, None)
1889 
1890     def __getfield_zero4(self):
1891         try: self.__field_zero4
1892         except:
1893             self.__field_zero4=UNKNOWN(**{'sizeinbytes': 112,  'pad': 0 })
1894         return self.__field_zero4.getvalue()
1895 
1896     def __setfield_zero4(self, value):
1897         if isinstance(value,UNKNOWN):
1898             self.__field_zero4=value
1899         else:
1900             self.__field_zero4=UNKNOWN(value,**{'sizeinbytes': 112,  'pad': 0 })
1901 
1902     def __delfield_zero4(self): del self.__field_zero4
1903 
1904     zero4=property(__getfield_zero4, __setfield_zero4, __delfield_zero4, None)
1905 
1906     def __getfield_events(self):
1907         try: self.__field_events
1908         except:
1909             self.__field_events=LIST(**{ 'elementclass': CalIndexEntry,             'length': 103,             'createdefault': True })
1910         return self.__field_events.getvalue()
1911 
1912     def __setfield_events(self, value):
1913         if isinstance(value,LIST):
1914             self.__field_events=value
1915         else:
1916             self.__field_events=LIST(value,**{ 'elementclass': CalIndexEntry,             'length': 103,             'createdefault': True })
1917 
1918     def __delfield_events(self): del self.__field_events
1919 
1920     events=property(__getfield_events, __setfield_events, __delfield_events, None)
1921 
1922     def __getfield_notes(self):
1923         try: self.__field_notes
1924         except:
1925             self.__field_notes=LIST(**{ 'elementclass': CalIndexEntry,             'length': 35,             'createdefault': True })
1926         return self.__field_notes.getvalue()
1927 
1928     def __setfield_notes(self, value):
1929         if isinstance(value,LIST):
1930             self.__field_notes=value
1931         else:
1932             self.__field_notes=LIST(value,**{ 'elementclass': CalIndexEntry,             'length': 35,             'createdefault': True })
1933 
1934     def __delfield_notes(self): del self.__field_notes
1935 
1936     notes=property(__getfield_notes, __setfield_notes, __delfield_notes, None)
1937 
1938     def __getfield_activeevents(self):
1939         try: self.__field_activeevents
1940         except:
1941             self.__field_activeevents=LIST(**{ 'elementclass': CalIndexEntry,             'length': 319,             'createdefault': True })
1942         return self.__field_activeevents.getvalue()
1943 
1944     def __setfield_activeevents(self, value):
1945         if isinstance(value,LIST):
1946             self.__field_activeevents=value
1947         else:
1948             self.__field_activeevents=LIST(value,**{ 'elementclass': CalIndexEntry,             'length': 319,             'createdefault': True })
1949 
1950     def __delfield_activeevents(self): del self.__field_activeevents
1951 
1952     activeevents=property(__getfield_activeevents, __setfield_activeevents, __delfield_activeevents, None)
1953 
1954     def iscontainer(self):
1955         return True
1956 
1957     def containerelements(self):
1958         yield ('next_index', self.__field_next_index, None)
1959         yield ('zero1', self.__field_zero1, None)
1960         yield ('numofevents', self.__field_numofevents, None)
1961         yield ('zero2', self.__field_zero2, None)
1962         yield ('numofnotes', self.__field_numofnotes, None)
1963         yield ('zero3', self.__field_zero3, None)
1964         yield ('numofactiveevents', self.__field_numofactiveevents, None)
1965         yield ('zero4', self.__field_zero4, None)
1966         yield ('events', self.__field_events, None)
1967         yield ('notes', self.__field_notes, None)
1968         yield ('activeevents', self.__field_activeevents, None)
1969 
1970 
1971 
1972 
1973 class CalEntry(BaseProtogenClass):
1974     __fields=['titlelen', 'title', 'start', 'zero1', 'start2', 'zero2', 'exptime', 'zero3', 'one', 'repeat', 'three', 'alarm', 'alert', 'zero4', 'duration', 'timezone', 'creationtime', 'zero5', 'modifiedtime', 'zero6', 'ringtonelen', 'ringtone', 'zero7']
1975 
1976     def __init__(self, *args, **kwargs):
1977         dict={}
1978         # What was supplied to this function
1979         dict.update(kwargs)
1980         # Parent constructor
1981         super(CalEntry,self).__init__(**dict)
1982         if self.__class__ is CalEntry:
1983             self._update(args,dict)
1984 
1985 
1986     def getfields(self):
1987         return self.__fields
1988 
1989 
1990     def _update(self, args, kwargs):
1991         super(CalEntry,self)._update(args,kwargs)
1992         keys=kwargs.keys()
1993         for key in keys:
1994             if key in self.__fields:
1995                 setattr(self, key, kwargs[key])
1996                 del kwargs[key]
1997         # Were any unrecognized kwargs passed in?
1998         if __debug__:
1999             self._complainaboutunusedargs(CalEntry,kwargs)
2000         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2001         # Make all P fields that haven't already been constructed
2002 
2003 
2004     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2005         'Writes this packet to the supplied buffer'
2006         self._bufferstartoffset=buf.getcurrentoffset()
2007         self.__field_titlelen.writetobuffer(buf)
2008         self.__field_title.writetobuffer(buf)
2009         self.__field_start.writetobuffer(buf)
2010         try: self.__field_zero1
2011         except:
2012             self.__field_zero1=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 })
2013         self.__field_zero1.writetobuffer(buf)
2014         try: self.__field_start2
2015         except:
2016             self.__field_start2=DateTime(**{'sizeinbytes': 4,  'default': self.start })
2017         self.__field_start2.writetobuffer(buf)
2018         try: self.__field_zero2
2019         except:
2020             self.__field_zero2=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 })
2021         self.__field_zero2.writetobuffer(buf)
2022         self.__field_exptime.writetobuffer(buf)
2023         try: self.__field_zero3
2024         except:
2025             self.__field_zero3=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 })
2026         self.__field_zero3.writetobuffer(buf)
2027         try: self.__field_one
2028         except:
2029             self.__field_one=UINT(**{'sizeinbytes': 1,  'default': 1 })
2030         self.__field_one.writetobuffer(buf)
2031         self.__field_repeat.writetobuffer(buf)
2032         try: self.__field_three
2033         except:
2034             self.__field_three=UINT(**{'sizeinbytes': 1,  'default': 3 })
2035         self.__field_three.writetobuffer(buf)
2036         self.__field_alarm.writetobuffer(buf)
2037         self.__field_alert.writetobuffer(buf)
2038         try: self.__field_zero4
2039         except:
2040             self.__field_zero4=UNKNOWN(**{'sizeinbytes': 6,  'pad': 0 })
2041         self.__field_zero4.writetobuffer(buf)
2042         self.__field_duration.writetobuffer(buf)
2043         self.__field_timezone.writetobuffer(buf)
2044         self.__field_creationtime.writetobuffer(buf)
2045         try: self.__field_zero5
2046         except:
2047             self.__field_zero5=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 })
2048         self.__field_zero5.writetobuffer(buf)
2049         self.__field_modifiedtime.writetobuffer(buf)
2050         try: self.__field_zero6
2051         except:
2052             self.__field_zero6=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 })
2053         self.__field_zero6.writetobuffer(buf)
2054         self.__field_ringtonelen.writetobuffer(buf)
2055         self.__field_ringtone.writetobuffer(buf)
2056         try: self.__field_zero7
2057         except:
2058             self.__field_zero7=UNKNOWN(**{'sizeinbytes': 2,  'pad': 0 })
2059         self.__field_zero7.writetobuffer(buf)
2060         self._bufferendoffset=buf.getcurrentoffset()
2061         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2062 
2063 
2064     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2065         'Reads this packet from the supplied buffer'
2066         self._bufferstartoffset=buf.getcurrentoffset()
2067         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2068         self.__field_titlelen=UINT(**{'sizeinbytes': 2})
2069         self.__field_titlelen.readfrombuffer(buf)
2070         self.__field_title=USTRING(**{ 'sizeinbytes': self.titlelen,                'encoding': ENCODING,                'terminator': None })
2071         self.__field_title.readfrombuffer(buf)
2072         self.__field_start=DateTime(**{'sizeinbytes': 4})
2073         self.__field_start.readfrombuffer(buf)
2074         self.__field_zero1=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 })
2075         self.__field_zero1.readfrombuffer(buf)
2076         self.__field_start2=DateTime(**{'sizeinbytes': 4,  'default': self.start })
2077         self.__field_start2.readfrombuffer(buf)
2078         self.__field_zero2=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 })
2079         self.__field_zero2.readfrombuffer(buf)
2080         self.__field_exptime=ExpiringTime(**{'sizeinbytes': 4})
2081         self.__field_exptime.readfrombuffer(buf)
2082         self.__field_zero3=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 })
2083         self.__field_zero3.readfrombuffer(buf)
2084         self.__field_one=UINT(**{'sizeinbytes': 1,  'default': 1 })
2085         self.__field_one.readfrombuffer(buf)
2086         self.__field_repeat=UINT(**{'sizeinbytes': 1})
2087         self.__field_repeat.readfrombuffer(buf)
2088         self.__field_three=UINT(**{'sizeinbytes': 1,  'default': 3 })
2089         self.__field_three.readfrombuffer(buf)
2090         self.__field_alarm=UINT(**{'sizeinbytes': 1})
2091         self.__field_alarm.readfrombuffer(buf)
2092         self.__field_alert=UINT(**{'sizeinbytes': 1})
2093         self.__field_alert.readfrombuffer(buf)
2094         self.__field_zero4=UNKNOWN(**{'sizeinbytes': 6,  'pad': 0 })
2095         self.__field_zero4.readfrombuffer(buf)
2096         self.__field_duration=UINT(**{'sizeinbytes': 4})
2097         self.__field_duration.readfrombuffer(buf)
2098         self.__field_timezone=UINT(**{'sizeinbytes': 1})
2099         self.__field_timezone.readfrombuffer(buf)
2100         self.__field_creationtime=DateTime(**{'sizeinbytes': 4})
2101         self.__field_creationtime.readfrombuffer(buf)
2102         self.__field_zero5=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 })
2103         self.__field_zero5.readfrombuffer(buf)
2104         self.__field_modifiedtime=DateTime(**{'sizeinbytes': 4})
2105         self.__field_modifiedtime.readfrombuffer(buf)
2106         self.__field_zero6=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 })
2107         self.__field_zero6.readfrombuffer(buf)
2108         self.__field_ringtonelen=UINT(**{'sizeinbytes': 2})
2109         self.__field_ringtonelen.readfrombuffer(buf)
2110         self.__field_ringtone=STRING(**{ 'sizeinbytes': self.ringtonelen,               'terminator': None })
2111         self.__field_ringtone.readfrombuffer(buf)
2112         self.__field_zero7=UNKNOWN(**{'sizeinbytes': 2,  'pad': 0 })
2113         self.__field_zero7.readfrombuffer(buf)
2114         self._bufferendoffset=buf.getcurrentoffset()
2115 
2116 
2117     def __getfield_titlelen(self):
2118         return self.__field_titlelen.getvalue()
2119 
2120     def __setfield_titlelen(self, value):
2121         if isinstance(value,UINT):
2122             self.__field_titlelen=value
2123         else:
2124             self.__field_titlelen=UINT(value,**{'sizeinbytes': 2})
2125 
2126     def __delfield_titlelen(self): del self.__field_titlelen
2127 
2128     titlelen=property(__getfield_titlelen, __setfield_titlelen, __delfield_titlelen, None)
2129 
2130     def __getfield_title(self):
2131         return self.__field_title.getvalue()
2132 
2133     def __setfield_title(self, value):
2134         if isinstance(value,USTRING):
2135             self.__field_title=value
2136         else:
2137             self.__field_title=USTRING(value,**{ 'sizeinbytes': self.titlelen,                'encoding': ENCODING,                'terminator': None })
2138 
2139     def __delfield_title(self): del self.__field_title
2140 
2141     title=property(__getfield_title, __setfield_title, __delfield_title, None)
2142 
2143     def __getfield_start(self):
2144         return self.__field_start.getvalue()
2145 
2146     def __setfield_start(self, value):
2147         if isinstance(value,DateTime):
2148             self.__field_start=value
2149         else:
2150             self.__field_start=DateTime(value,**{'sizeinbytes': 4})
2151 
2152     def __delfield_start(self): del self.__field_start
2153 
2154     start=property(__getfield_start, __setfield_start, __delfield_start, None)
2155 
2156     def __getfield_zero1(self):
2157         try: self.__field_zero1
2158         except:
2159             self.__field_zero1=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 })
2160         return self.__field_zero1.getvalue()
2161 
2162     def __setfield_zero1(self, value):
2163         if isinstance(value,UNKNOWN):
2164             self.__field_zero1=value
2165         else:
2166             self.__field_zero1=UNKNOWN(value,**{'sizeinbytes': 4,  'pad': 0 })
2167 
2168     def __delfield_zero1(self): del self.__field_zero1
2169 
2170     zero1=property(__getfield_zero1, __setfield_zero1, __delfield_zero1, None)
2171 
2172     def __getfield_start2(self):
2173         try: self.__field_start2
2174         except:
2175             self.__field_start2=DateTime(**{'sizeinbytes': 4,  'default': self.start })
2176         return self.__field_start2.getvalue()
2177 
2178     def __setfield_start2(self, value):
2179         if isinstance(value,DateTime):
2180             self.__field_start2=value
2181         else:
2182             self.__field_start2=DateTime(value,**{'sizeinbytes': 4,  'default': self.start })
2183 
2184     def __delfield_start2(self): del self.__field_start2
2185 
2186     start2=property(__getfield_start2, __setfield_start2, __delfield_start2, None)
2187 
2188     def __getfield_zero2(self):
2189         try: self.__field_zero2
2190         except:
2191             self.__field_zero2=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 })
2192         return self.__field_zero2.getvalue()
2193 
2194     def __setfield_zero2(self, value):
2195         if isinstance(value,UNKNOWN):
2196             self.__field_zero2=value
2197         else:
2198             self.__field_zero2=UNKNOWN(value,**{'sizeinbytes': 4,  'pad': 0 })
2199 
2200     def __delfield_zero2(self): del self.__field_zero2
2201 
2202     zero2=property(__getfield_zero2, __setfield_zero2, __delfield_zero2, None)
2203 
2204     def __getfield_exptime(self):
2205         return self.__field_exptime.getvalue()
2206 
2207     def __setfield_exptime(self, value):
2208         if isinstance(value,ExpiringTime):
2209             self.__field_exptime=value
2210         else:
2211             self.__field_exptime=ExpiringTime(value,**{'sizeinbytes': 4})
2212 
2213     def __delfield_exptime(self): del self.__field_exptime
2214 
2215     exptime=property(__getfield_exptime, __setfield_exptime, __delfield_exptime, None)
2216 
2217     def __getfield_zero3(self):
2218         try: self.__field_zero3
2219         except:
2220             self.__field_zero3=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 })
2221         return self.__field_zero3.getvalue()
2222 
2223     def __setfield_zero3(self, value):
2224         if isinstance(value,UNKNOWN):
2225             self.__field_zero3=value
2226         else:
2227             self.__field_zero3=UNKNOWN(value,**{'sizeinbytes': 4,  'pad': 0 })
2228 
2229     def __delfield_zero3(self): del self.__field_zero3
2230 
2231     zero3=property(__getfield_zero3, __setfield_zero3, __delfield_zero3, None)
2232 
2233     def __getfield_one(self):
2234         try: self.__field_one
2235         except:
2236             self.__field_one=UINT(**{'sizeinbytes': 1,  'default': 1 })
2237         return self.__field_one.getvalue()
2238 
2239     def __setfield_one(self, value):
2240         if isinstance(value,UINT):
2241             self.__field_one=value
2242         else:
2243             self.__field_one=UINT(value,**{'sizeinbytes': 1,  'default': 1 })
2244 
2245     def __delfield_one(self): del self.__field_one
2246 
2247     one=property(__getfield_one, __setfield_one, __delfield_one, None)
2248 
2249     def __getfield_repeat(self):
2250         return self.__field_repeat.getvalue()
2251 
2252     def __setfield_repeat(self, value):
2253         if isinstance(value,UINT):
2254             self.__field_repeat=value
2255         else:
2256             self.__field_repeat=UINT(value,**{'sizeinbytes': 1})
2257 
2258     def __delfield_repeat(self): del self.__field_repeat
2259 
2260     repeat=property(__getfield_repeat, __setfield_repeat, __delfield_repeat, None)
2261 
2262     def __getfield_three(self):
2263         try: self.__field_three
2264         except:
2265             self.__field_three=UINT(**{'sizeinbytes': 1,  'default': 3 })
2266         return self.__field_three.getvalue()
2267 
2268     def __setfield_three(self, value):
2269         if isinstance(value,UINT):
2270             self.__field_three=value
2271         else:
2272             self.__field_three=UINT(value,**{'sizeinbytes': 1,  'default': 3 })
2273 
2274     def __delfield_three(self): del self.__field_three
2275 
2276     three=property(__getfield_three, __setfield_three, __delfield_three, None)
2277 
2278     def __getfield_alarm(self):
2279         return self.__field_alarm.getvalue()
2280 
2281     def __setfield_alarm(self, value):
2282         if isinstance(value,UINT):
2283             self.__field_alarm=value
2284         else:
2285             self.__field_alarm=UINT(value,**{'sizeinbytes': 1})
2286 
2287     def __delfield_alarm(self): del self.__field_alarm
2288 
2289     alarm=property(__getfield_alarm, __setfield_alarm, __delfield_alarm, None)
2290 
2291     def __getfield_alert(self):
2292         return self.__field_alert.getvalue()
2293 
2294     def __setfield_alert(self, value):
2295         if isinstance(value,UINT):
2296             self.__field_alert=value
2297         else:
2298             self.__field_alert=UINT(value,**{'sizeinbytes': 1})
2299 
2300     def __delfield_alert(self): del self.__field_alert
2301 
2302     alert=property(__getfield_alert, __setfield_alert, __delfield_alert, None)
2303 
2304     def __getfield_zero4(self):
2305         try: self.__field_zero4
2306         except:
2307             self.__field_zero4=UNKNOWN(**{'sizeinbytes': 6,  'pad': 0 })
2308         return self.__field_zero4.getvalue()
2309 
2310     def __setfield_zero4(self, value):
2311         if isinstance(value,UNKNOWN):
2312             self.__field_zero4=value
2313         else:
2314             self.__field_zero4=UNKNOWN(value,**{'sizeinbytes': 6,  'pad': 0 })
2315 
2316     def __delfield_zero4(self): del self.__field_zero4
2317 
2318     zero4=property(__getfield_zero4, __setfield_zero4, __delfield_zero4, None)
2319 
2320     def __getfield_duration(self):
2321         return self.__field_duration.getvalue()
2322 
2323     def __setfield_duration(self, value):
2324         if isinstance(value,UINT):
2325             self.__field_duration=value
2326         else:
2327             self.__field_duration=UINT(value,**{'sizeinbytes': 4})
2328 
2329     def __delfield_duration(self): del self.__field_duration
2330 
2331     duration=property(__getfield_duration, __setfield_duration, __delfield_duration, None)
2332 
2333     def __getfield_timezone(self):
2334         return self.__field_timezone.getvalue()
2335 
2336     def __setfield_timezone(self, value):
2337         if isinstance(value,UINT):
2338             self.__field_timezone=value
2339         else:
2340             self.__field_timezone=UINT(value,**{'sizeinbytes': 1})
2341 
2342     def __delfield_timezone(self): del self.__field_timezone
2343 
2344     timezone=property(__getfield_timezone, __setfield_timezone, __delfield_timezone, None)
2345 
2346     def __getfield_creationtime(self):
2347         return self.__field_creationtime.getvalue()
2348 
2349     def __setfield_creationtime(self, value):
2350         if isinstance(value,DateTime):
2351             self.__field_creationtime=value
2352         else:
2353             self.__field_creationtime=DateTime(value,**{'sizeinbytes': 4})
2354 
2355     def __delfield_creationtime(self): del self.__field_creationtime
2356 
2357     creationtime=property(__getfield_creationtime, __setfield_creationtime, __delfield_creationtime, None)
2358 
2359     def __getfield_zero5(self):
2360         try: self.__field_zero5
2361         except:
2362             self.__field_zero5=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 })
2363         return self.__field_zero5.getvalue()
2364 
2365     def __setfield_zero5(self, value):
2366         if isinstance(value,UNKNOWN):
2367             self.__field_zero5=value
2368         else:
2369             self.__field_zero5=UNKNOWN(value,**{'sizeinbytes': 4,  'pad': 0 })
2370 
2371     def __delfield_zero5(self): del self.__field_zero5
2372 
2373     zero5=property(__getfield_zero5, __setfield_zero5, __delfield_zero5, None)
2374 
2375     def __getfield_modifiedtime(self):
2376         return self.__field_modifiedtime.getvalue()
2377 
2378     def __setfield_modifiedtime(self, value):
2379         if isinstance(value,DateTime):
2380             self.__field_modifiedtime=value
2381         else:
2382             self.__field_modifiedtime=DateTime(value,**{'sizeinbytes': 4})
2383 
2384     def __delfield_modifiedtime(self): del self.__field_modifiedtime
2385 
2386     modifiedtime=property(__getfield_modifiedtime, __setfield_modifiedtime, __delfield_modifiedtime, None)
2387 
2388     def __getfield_zero6(self):
2389         try: self.__field_zero6
2390         except:
2391             self.__field_zero6=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 })
2392         return self.__field_zero6.getvalue()
2393 
2394     def __setfield_zero6(self, value):
2395         if isinstance(value,UNKNOWN):
2396             self.__field_zero6=value
2397         else:
2398             self.__field_zero6=UNKNOWN(value,**{'sizeinbytes': 4,  'pad': 0 })
2399 
2400     def __delfield_zero6(self): del self.__field_zero6
2401 
2402     zero6=property(__getfield_zero6, __setfield_zero6, __delfield_zero6, None)
2403 
2404     def __getfield_ringtonelen(self):
2405         return self.__field_ringtonelen.getvalue()
2406 
2407     def __setfield_ringtonelen(self, value):
2408         if isinstance(value,UINT):
2409             self.__field_ringtonelen=value
2410         else:
2411             self.__field_ringtonelen=UINT(value,**{'sizeinbytes': 2})
2412 
2413     def __delfield_ringtonelen(self): del self.__field_ringtonelen
2414 
2415     ringtonelen=property(__getfield_ringtonelen, __setfield_ringtonelen, __delfield_ringtonelen, None)
2416 
2417     def __getfield_ringtone(self):
2418         return self.__field_ringtone.getvalue()
2419 
2420     def __setfield_ringtone(self, value):
2421         if isinstance(value,STRING):
2422             self.__field_ringtone=value
2423         else:
2424             self.__field_ringtone=STRING(value,**{ 'sizeinbytes': self.ringtonelen,               'terminator': None })
2425 
2426     def __delfield_ringtone(self): del self.__field_ringtone
2427 
2428     ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None)
2429 
2430     def __getfield_zero7(self):
2431         try: self.__field_zero7
2432         except:
2433             self.__field_zero7=UNKNOWN(**{'sizeinbytes': 2,  'pad': 0 })
2434         return self.__field_zero7.getvalue()
2435 
2436     def __setfield_zero7(self, value):
2437         if isinstance(value,UNKNOWN):
2438             self.__field_zero7=value
2439         else:
2440             self.__field_zero7=UNKNOWN(value,**{'sizeinbytes': 2,  'pad': 0 })
2441 
2442     def __delfield_zero7(self): del self.__field_zero7
2443 
2444     zero7=property(__getfield_zero7, __setfield_zero7, __delfield_zero7, None)
2445 
2446     def iscontainer(self):
2447         return True
2448 
2449     def containerelements(self):
2450         yield ('titlelen', self.__field_titlelen, None)
2451         yield ('title', self.__field_title, None)
2452         yield ('start', self.__field_start, None)
2453         yield ('zero1', self.__field_zero1, None)
2454         yield ('start2', self.__field_start2, None)
2455         yield ('zero2', self.__field_zero2, None)
2456         yield ('exptime', self.__field_exptime, None)
2457         yield ('zero3', self.__field_zero3, None)
2458         yield ('one', self.__field_one, None)
2459         yield ('repeat', self.__field_repeat, None)
2460         yield ('three', self.__field_three, None)
2461         yield ('alarm', self.__field_alarm, None)
2462         yield ('alert', self.__field_alert, None)
2463         yield ('zero4', self.__field_zero4, None)
2464         yield ('duration', self.__field_duration, None)
2465         yield ('timezone', self.__field_timezone, None)
2466         yield ('creationtime', self.__field_creationtime, None)
2467         yield ('zero5', self.__field_zero5, None)
2468         yield ('modifiedtime', self.__field_modifiedtime, None)
2469         yield ('zero6', self.__field_zero6, None)
2470         yield ('ringtonelen', self.__field_ringtonelen, None)
2471         yield ('ringtone', self.__field_ringtone, None)
2472         yield ('zero7', self.__field_zero7, None)
2473 
2474 
2475 
2476 
2477 class NotePadEntry(BaseProtogenClass):
2478     __fields=['textlen', 'text', 'creation', 'zero1', 'creation2', 'zero2', 'five', 'zero3', 'modified', 'zero4', 'modified2', 'zero5']
2479 
2480     def __init__(self, *args, **kwargs):
2481         dict={}
2482         # What was supplied to this function
2483         dict.update(kwargs)
2484         # Parent constructor
2485         super(NotePadEntry,self).__init__(**dict)
2486         if self.__class__ is NotePadEntry:
2487             self._update(args,dict)
2488 
2489 
2490     def getfields(self):
2491         return self.__fields
2492 
2493 
2494     def _update(self, args, kwargs):
2495         super(NotePadEntry,self)._update(args,kwargs)
2496         keys=kwargs.keys()
2497         for key in keys:
2498             if key in self.__fields:
2499                 setattr(self, key, kwargs[key])
2500                 del kwargs[key]
2501         # Were any unrecognized kwargs passed in?
2502         if __debug__:
2503             self._complainaboutunusedargs(NotePadEntry,kwargs)
2504         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2505         # Make all P fields that haven't already been constructed
2506 
2507 
2508     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2509         'Writes this packet to the supplied buffer'
2510         self._bufferstartoffset=buf.getcurrentoffset()
2511         self.__field_textlen.writetobuffer(buf)
2512         self.__field_text.writetobuffer(buf)
2513         self.__field_creation.writetobuffer(buf)
2514         try: self.__field_zero1
2515         except:
2516             self.__field_zero1=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 })
2517         self.__field_zero1.writetobuffer(buf)
2518         try: self.__field_creation2
2519         except:
2520             self.__field_creation2=DateTime(**{'sizeinbytes': 4,  'default': self.creation })
2521         self.__field_creation2.writetobuffer(buf)
2522         try: self.__field_zero2
2523         except:
2524             self.__field_zero2=UNKNOWN(**{'sizeinbytes': 14,  'pad': 0 })
2525         self.__field_zero2.writetobuffer(buf)
2526         try: self.__field_five
2527         except:
2528             self.__field_five=UINT(**{'sizeinbytes': 1,  'default': 5 })
2529         self.__field_five.writetobuffer(buf)
2530         try: self.__field_zero3
2531         except:
2532             self.__field_zero3=UNKNOWN(**{'sizeinbytes': 13,  'pad': 0 })
2533         self.__field_zero3.writetobuffer(buf)
2534         try: self.__field_modified
2535         except:
2536             self.__field_modified=DateTime(**{'sizeinbytes': 4,  'default': self.creation })
2537         self.__field_modified.writetobuffer(buf)
2538         try: self.__field_zero4
2539         except:
2540             self.__field_zero4=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 })
2541         self.__field_zero4.writetobuffer(buf)
2542         try: self.__field_modified2
2543         except:
2544             self.__field_modified2=DateTime(**{'sizeinbytes': 4,  'default': self.modified })
2545         self.__field_modified2.writetobuffer(buf)
2546         try: self.__field_zero5
2547         except:
2548             self.__field_zero5=UNKNOWN(**{'sizeinbytes': 8,  'pad': 0 })
2549         self.__field_zero5.writetobuffer(buf)
2550         self._bufferendoffset=buf.getcurrentoffset()
2551         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2552 
2553 
2554     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2555         'Reads this packet from the supplied buffer'
2556         self._bufferstartoffset=buf.getcurrentoffset()
2557         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2558         self.__field_textlen=UINT(**{'sizeinbytes': 2})
2559         self.__field_textlen.readfrombuffer(buf)
2560         self.__field_text=USTRING(**{ 'terminator': None,                'encoding': ENCODING,                'sizeinbytes': self.textlen })
2561         self.__field_text.readfrombuffer(buf)
2562         self.__field_creation=DateTime(**{'sizeinbytes': 4})
2563         self.__field_creation.readfrombuffer(buf)
2564         self.__field_zero1=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 })
2565         self.__field_zero1.readfrombuffer(buf)
2566         self.__field_creation2=DateTime(**{'sizeinbytes': 4,  'default': self.creation })
2567         self.__field_creation2.readfrombuffer(buf)
2568         self.__field_zero2=UNKNOWN(**{'sizeinbytes': 14,  'pad': 0 })
2569         self.__field_zero2.readfrombuffer(buf)
2570         self.__field_five=UINT(**{'sizeinbytes': 1,  'default': 5 })
2571         self.__field_five.readfrombuffer(buf)
2572         self.__field_zero3=UNKNOWN(**{'sizeinbytes': 13,  'pad': 0 })
2573         self.__field_zero3.readfrombuffer(buf)
2574         self.__field_modified=DateTime(**{'sizeinbytes': 4,  'default': self.creation })
2575         self.__field_modified.readfrombuffer(buf)
2576         self.__field_zero4=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 })
2577         self.__field_zero4.readfrombuffer(buf)
2578         self.__field_modified2=DateTime(**{'sizeinbytes': 4,  'default': self.modified })
2579         self.__field_modified2.readfrombuffer(buf)
2580         self.__field_zero5=UNKNOWN(**{'sizeinbytes': 8,  'pad': 0 })
2581         self.__field_zero5.readfrombuffer(buf)
2582         self._bufferendoffset=buf.getcurrentoffset()
2583 
2584 
2585     def __getfield_textlen(self):
2586         return self.__field_textlen.getvalue()
2587 
2588     def __setfield_textlen(self, value):
2589         if isinstance(value,UINT):
2590             self.__field_textlen=value
2591         else:
2592             self.__field_textlen=UINT(value,**{'sizeinbytes': 2})
2593 
2594     def __delfield_textlen(self): del self.__field_textlen
2595 
2596     textlen=property(__getfield_textlen, __setfield_textlen, __delfield_textlen, None)
2597 
2598     def __getfield_text(self):
2599         return self.__field_text.getvalue()
2600 
2601     def __setfield_text(self, value):
2602         if isinstance(value,USTRING):
2603             self.__field_text=value
2604         else:
2605             self.__field_text=USTRING(value,**{ 'terminator': None,                'encoding': ENCODING,                'sizeinbytes': self.textlen })
2606 
2607     def __delfield_text(self): del self.__field_text
2608 
2609     text=property(__getfield_text, __setfield_text, __delfield_text, None)
2610 
2611     def __getfield_creation(self):
2612         return self.__field_creation.getvalue()
2613 
2614     def __setfield_creation(self, value):
2615         if isinstance(value,DateTime):
2616             self.__field_creation=value
2617         else:
2618             self.__field_creation=DateTime(value,**{'sizeinbytes': 4})
2619 
2620     def __delfield_creation(self): del self.__field_creation
2621 
2622     creation=property(__getfield_creation, __setfield_creation, __delfield_creation, None)
2623 
2624     def __getfield_zero1(self):
2625         try: self.__field_zero1
2626         except:
2627             self.__field_zero1=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 })
2628         return self.__field_zero1.getvalue()
2629 
2630     def __setfield_zero1(self, value):
2631         if isinstance(value,UNKNOWN):
2632             self.__field_zero1=value
2633         else:
2634             self.__field_zero1=UNKNOWN(value,**{'sizeinbytes': 4,  'pad': 0 })
2635 
2636     def __delfield_zero1(self): del self.__field_zero1
2637 
2638     zero1=property(__getfield_zero1, __setfield_zero1, __delfield_zero1, None)
2639 
2640     def __getfield_creation2(self):
2641         try: self.__field_creation2
2642         except:
2643             self.__field_creation2=DateTime(**{'sizeinbytes': 4,  'default': self.creation })
2644         return self.__field_creation2.getvalue()
2645 
2646     def __setfield_creation2(self, value):
2647         if isinstance(value,DateTime):
2648             self.__field_creation2=value
2649         else:
2650             self.__field_creation2=DateTime(value,**{'sizeinbytes': 4,  'default': self.creation })
2651 
2652     def __delfield_creation2(self): del self.__field_creation2
2653 
2654     creation2=property(__getfield_creation2, __setfield_creation2, __delfield_creation2, None)
2655 
2656     def __getfield_zero2(self):
2657         try: self.__field_zero2
2658         except:
2659             self.__field_zero2=UNKNOWN(**{'sizeinbytes': 14,  'pad': 0 })
2660         return self.__field_zero2.getvalue()
2661 
2662     def __setfield_zero2(self, value):
2663         if isinstance(value,UNKNOWN):
2664             self.__field_zero2=value
2665         else:
2666             self.__field_zero2=UNKNOWN(value,**{'sizeinbytes': 14,  'pad': 0 })
2667 
2668     def __delfield_zero2(self): del self.__field_zero2
2669 
2670     zero2=property(__getfield_zero2, __setfield_zero2, __delfield_zero2, None)
2671 
2672     def __getfield_five(self):
2673         try: self.__field_five
2674         except:
2675             self.__field_five=UINT(**{'sizeinbytes': 1,  'default': 5 })
2676         return self.__field_five.getvalue()
2677 
2678     def __setfield_five(self, value):
2679         if isinstance(value,UINT):
2680             self.__field_five=value
2681         else:
2682             self.__field_five=UINT(value,**{'sizeinbytes': 1,  'default': 5 })
2683 
2684     def __delfield_five(self): del self.__field_five
2685 
2686     five=property(__getfield_five, __setfield_five, __delfield_five, None)
2687 
2688     def __getfield_zero3(self):
2689         try: self.__field_zero3
2690         except:
2691             self.__field_zero3=UNKNOWN(**{'sizeinbytes': 13,  'pad': 0 })
2692         return self.__field_zero3.getvalue()
2693 
2694     def __setfield_zero3(self, value):
2695         if isinstance(value,UNKNOWN):
2696             self.__field_zero3=value
2697         else:
2698             self.__field_zero3=UNKNOWN(value,**{'sizeinbytes': 13,  'pad': 0 })
2699 
2700     def __delfield_zero3(self): del self.__field_zero3
2701 
2702     zero3=property(__getfield_zero3, __setfield_zero3, __delfield_zero3, None)
2703 
2704     def __getfield_modified(self):
2705         try: self.__field_modified
2706         except:
2707             self.__field_modified=DateTime(**{'sizeinbytes': 4,  'default': self.creation })
2708         return self.__field_modified.getvalue()
2709 
2710     def __setfield_modified(self, value):
2711         if isinstance(value,DateTime):
2712             self.__field_modified=value
2713         else:
2714             self.__field_modified=DateTime(value,**{'sizeinbytes': 4,  'default': self.creation })
2715 
2716     def __delfield_modified(self): del self.__field_modified
2717 
2718     modified=property(__getfield_modified, __setfield_modified, __delfield_modified, None)
2719 
2720     def __getfield_zero4(self):
2721         try: self.__field_zero4
2722         except:
2723             self.__field_zero4=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 })
2724         return self.__field_zero4.getvalue()
2725 
2726     def __setfield_zero4(self, value):
2727         if isinstance(value,UNKNOWN):
2728             self.__field_zero4=value
2729         else:
2730             self.__field_zero4=UNKNOWN(value,**{'sizeinbytes': 4,  'pad': 0 })
2731 
2732     def __delfield_zero4(self): del self.__field_zero4
2733 
2734     zero4=property(__getfield_zero4, __setfield_zero4, __delfield_zero4, None)
2735 
2736     def __getfield_modified2(self):
2737         try: self.__field_modified2
2738         except:
2739             self.__field_modified2=DateTime(**{'sizeinbytes': 4,  'default': self.modified })
2740         return self.__field_modified2.getvalue()
2741 
2742     def __setfield_modified2(self, value):
2743         if isinstance(value,DateTime):
2744             self.__field_modified2=value
2745         else:
2746             self.__field_modified2=DateTime(value,**{'sizeinbytes': 4,  'default': self.modified })
2747 
2748     def __delfield_modified2(self): del self.__field_modified2
2749 
2750     modified2=property(__getfield_modified2, __setfield_modified2, __delfield_modified2, None)
2751 
2752     def __getfield_zero5(self):
2753         try: self.__field_zero5
2754         except:
2755             self.__field_zero5=UNKNOWN(**{'sizeinbytes': 8,  'pad': 0 })
2756         return self.__field_zero5.getvalue()
2757 
2758     def __setfield_zero5(self, value):
2759         if isinstance(value,UNKNOWN):
2760             self.__field_zero5=value
2761         else:
2762             self.__field_zero5=UNKNOWN(value,**{'sizeinbytes': 8,  'pad': 0 })
2763 
2764     def __delfield_zero5(self): del self.__field_zero5
2765 
2766     zero5=property(__getfield_zero5, __setfield_zero5, __delfield_zero5, None)
2767 
2768     def iscontainer(self):
2769         return True
2770 
2771     def containerelements(self):
2772         yield ('textlen', self.__field_textlen, None)
2773         yield ('text', self.__field_text, None)
2774         yield ('creation', self.__field_creation, None)
2775         yield ('zero1', self.__field_zero1, None)
2776         yield ('creation2', self.__field_creation2, None)
2777         yield ('zero2', self.__field_zero2, None)
2778         yield ('five', self.__field_five, None)
2779         yield ('zero3', self.__field_zero3, None)
2780         yield ('modified', self.__field_modified, None)
2781         yield ('zero4', self.__field_zero4, None)
2782         yield ('modified2', self.__field_modified2, None)
2783         yield ('zero5', self.__field_zero5, None)
2784 
2785 
2786 
2787 
2788 class cl_list(BaseProtogenClass):
2789     __fields=['index']
2790 
2791     def __init__(self, *args, **kwargs):
2792         dict={}
2793         # What was supplied to this function
2794         dict.update(kwargs)
2795         # Parent constructor
2796         super(cl_list,self).__init__(**dict)
2797         if self.__class__ is cl_list:
2798             self._update(args,dict)
2799 
2800 
2801     def getfields(self):
2802         return self.__fields
2803 
2804 
2805     def _update(self, args, kwargs):
2806         super(cl_list,self)._update(args,kwargs)
2807         keys=kwargs.keys()
2808         for key in keys:
2809             if key in self.__fields:
2810                 setattr(self, key, kwargs[key])
2811                 del kwargs[key]
2812         # Were any unrecognized kwargs passed in?
2813         if __debug__:
2814             self._complainaboutunusedargs(cl_list,kwargs)
2815         if len(args):
2816             dict2={'sizeinbytes': 2}
2817             dict2.update(kwargs)
2818             kwargs=dict2
2819             self.__field_index=UINT(*args,**dict2)
2820         # Make all P fields that haven't already been constructed
2821 
2822 
2823     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2824         'Writes this packet to the supplied buffer'
2825         self._bufferstartoffset=buf.getcurrentoffset()
2826         self.__field_index.writetobuffer(buf)
2827         self._bufferendoffset=buf.getcurrentoffset()
2828         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2829 
2830 
2831     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2832         'Reads this packet from the supplied buffer'
2833         self._bufferstartoffset=buf.getcurrentoffset()
2834         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2835         self.__field_index=UINT(**{'sizeinbytes': 2})
2836         self.__field_index.readfrombuffer(buf)
2837         self._bufferendoffset=buf.getcurrentoffset()
2838 
2839 
2840     def __getfield_index(self):
2841         return self.__field_index.getvalue()
2842 
2843     def __setfield_index(self, value):
2844         if isinstance(value,UINT):
2845             self.__field_index=value
2846         else:
2847             self.__field_index=UINT(value,**{'sizeinbytes': 2})
2848 
2849     def __delfield_index(self): del self.__field_index
2850 
2851     index=property(__getfield_index, __setfield_index, __delfield_index, None)
2852 
2853     def iscontainer(self):
2854         return True
2855 
2856     def containerelements(self):
2857         yield ('index', self.__field_index, None)
2858 
2859 
2860 
2861 
2862 class cl_index_file(BaseProtogenClass):
2863     __fields=['incoming', 'outgoing', 'missed', 'dunno1', 'incoming_count', 'outgoing_count', 'missed_count']
2864 
2865     def __init__(self, *args, **kwargs):
2866         dict={}
2867         # What was supplied to this function
2868         dict.update(kwargs)
2869         # Parent constructor
2870         super(cl_index_file,self).__init__(**dict)
2871         if self.__class__ is cl_index_file:
2872             self._update(args,dict)
2873 
2874 
2875     def getfields(self):
2876         return self.__fields
2877 
2878 
2879     def _update(self, args, kwargs):
2880         super(cl_index_file,self)._update(args,kwargs)
2881         keys=kwargs.keys()
2882         for key in keys:
2883             if key in self.__fields:
2884                 setattr(self, key, kwargs[key])
2885                 del kwargs[key]
2886         # Were any unrecognized kwargs passed in?
2887         if __debug__:
2888             self._complainaboutunusedargs(cl_index_file,kwargs)
2889         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2890         # Make all P fields that haven't already been constructed
2891 
2892 
2893     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2894         'Writes this packet to the supplied buffer'
2895         self._bufferstartoffset=buf.getcurrentoffset()
2896         self.__field_incoming.writetobuffer(buf)
2897         self.__field_outgoing.writetobuffer(buf)
2898         self.__field_missed.writetobuffer(buf)
2899         self.__field_dunno1.writetobuffer(buf)
2900         self.__field_incoming_count.writetobuffer(buf)
2901         self.__field_outgoing_count.writetobuffer(buf)
2902         self.__field_missed_count.writetobuffer(buf)
2903         self._bufferendoffset=buf.getcurrentoffset()
2904         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2905 
2906 
2907     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2908         'Reads this packet from the supplied buffer'
2909         self._bufferstartoffset=buf.getcurrentoffset()
2910         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2911         self.__field_incoming=LIST(**{ 'length': CL_MAX_ENTRIES,             'elementclass': cl_list })
2912         self.__field_incoming.readfrombuffer(buf)
2913         self.__field_outgoing=LIST(**{ 'length': CL_MAX_ENTRIES,             'elementclass': cl_list })
2914         self.__field_outgoing.readfrombuffer(buf)
2915         self.__field_missed=LIST(**{ 'length': CL_MAX_ENTRIES,             'elementclass': cl_list })
2916         self.__field_missed.readfrombuffer(buf)
2917         self.__field_dunno1=UNKNOWN(**{'sizeinbytes': 1352})
2918         self.__field_dunno1.readfrombuffer(buf)
2919         self.__field_incoming_count=UINT(**{'sizeinbytes': 4})
2920         self.__field_incoming_count.readfrombuffer(buf)
2921         self.__field_outgoing_count=UINT(**{'sizeinbytes': 4})
2922         self.__field_outgoing_count.readfrombuffer(buf)
2923         self.__field_missed_count=UINT(**{'sizeinbytes': 4})
2924         self.__field_missed_count.readfrombuffer(buf)
2925         self._bufferendoffset=buf.getcurrentoffset()
2926 
2927 
2928     def __getfield_incoming(self):
2929         return self.__field_incoming.getvalue()
2930 
2931     def __setfield_incoming(self, value):
2932         if isinstance(value,LIST):
2933             self.__field_incoming=value
2934         else:
2935             self.__field_incoming=LIST(value,**{ 'length': CL_MAX_ENTRIES,             'elementclass': cl_list })
2936 
2937     def __delfield_incoming(self): del self.__field_incoming
2938 
2939     incoming=property(__getfield_incoming, __setfield_incoming, __delfield_incoming, None)
2940 
2941     def __getfield_outgoing(self):
2942         return self.__field_outgoing.getvalue()
2943 
2944     def __setfield_outgoing(self, value):
2945         if isinstance(value,LIST):
2946             self.__field_outgoing=value
2947         else:
2948             self.__field_outgoing=LIST(value,**{ 'length': CL_MAX_ENTRIES,             'elementclass': cl_list })
2949 
2950     def __delfield_outgoing(self): del self.__field_outgoing
2951 
2952     outgoing=property(__getfield_outgoing, __setfield_outgoing, __delfield_outgoing, None)
2953 
2954     def __getfield_missed(self):
2955         return self.__field_missed.getvalue()
2956 
2957     def __setfield_missed(self, value):
2958         if isinstance(value,LIST):
2959             self.__field_missed=value
2960         else:
2961             self.__field_missed=LIST(value,**{ 'length': CL_MAX_ENTRIES,             'elementclass': cl_list })
2962 
2963     def __delfield_missed(self): del self.__field_missed
2964 
2965     missed=property(__getfield_missed, __setfield_missed, __delfield_missed, None)
2966 
2967     def __getfield_dunno1(self):
2968         return self.__field_dunno1.getvalue()
2969 
2970     def __setfield_dunno1(self, value):
2971         if isinstance(value,UNKNOWN):
2972             self.__field_dunno1=value
2973         else:
2974             self.__field_dunno1=UNKNOWN(value,**{'sizeinbytes': 1352})
2975 
2976     def __delfield_dunno1(self): del self.__field_dunno1
2977 
2978     dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None)
2979 
2980     def __getfield_incoming_count(self):
2981         return self.__field_incoming_count.getvalue()
2982 
2983     def __setfield_incoming_count(self, value):
2984         if isinstance(value,UINT):
2985             self.__field_incoming_count=value
2986         else:
2987             self.__field_incoming_count=UINT(value,**{'sizeinbytes': 4})
2988 
2989     def __delfield_incoming_count(self): del self.__field_incoming_count
2990 
2991     incoming_count=property(__getfield_incoming_count, __setfield_incoming_count, __delfield_incoming_count, None)
2992 
2993     def __getfield_outgoing_count(self):
2994         return self.__field_outgoing_count.getvalue()
2995 
2996     def __setfield_outgoing_count(self, value):
2997         if isinstance(value,UINT):
2998             self.__field_outgoing_count=value
2999         else:
3000             self.__field_outgoing_count=UINT(value,**{'sizeinbytes': 4})
3001 
3002     def __delfield_outgoing_count(self): del self.__field_outgoing_count
3003 
3004     outgoing_count=property(__getfield_outgoing_count, __setfield_outgoing_count, __delfield_outgoing_count, None)
3005 
3006     def __getfield_missed_count(self):
3007         return self.__field_missed_count.getvalue()
3008 
3009     def __setfield_missed_count(self, value):
3010         if isinstance(value,UINT):
3011             self.__field_missed_count=value
3012         else:
3013             self.__field_missed_count=UINT(value,**{'sizeinbytes': 4})
3014 
3015     def __delfield_missed_count(self): del self.__field_missed_count
3016 
3017     missed_count=property(__getfield_missed_count, __setfield_missed_count, __delfield_missed_count, None)
3018 
3019     def iscontainer(self):
3020         return True
3021 
3022     def containerelements(self):
3023         yield ('incoming', self.__field_incoming, None)
3024         yield ('outgoing', self.__field_outgoing, None)
3025         yield ('missed', self.__field_missed, None)
3026         yield ('dunno1', self.__field_dunno1, None)
3027         yield ('incoming_count', self.__field_incoming_count, None)
3028         yield ('outgoing_count', self.__field_outgoing_count, None)
3029         yield ('missed_count', self.__field_missed_count, None)
3030 
3031 
3032 
3033 
3034 class cl_file(BaseProtogenClass):
3035     __fields=['cl_type', 'number', 'datetime', 'dunno1', 'duration']
3036 
3037     def __init__(self, *args, **kwargs):
3038         dict={}
3039         # What was supplied to this function
3040         dict.update(kwargs)
3041         # Parent constructor
3042         super(cl_file,self).__init__(**dict)
3043         if self.__class__ is cl_file:
3044             self._update(args,dict)
3045 
3046 
3047     def getfields(self):
3048         return self.__fields
3049 
3050 
3051     def _update(self, args, kwargs):
3052         super(cl_file,self)._update(args,kwargs)
3053         keys=kwargs.keys()
3054         for key in keys:
3055             if key in self.__fields:
3056                 setattr(self, key, kwargs[key])
3057                 del kwargs[key]
3058         # Were any unrecognized kwargs passed in?
3059         if __debug__:
3060             self._complainaboutunusedargs(cl_file,kwargs)
3061         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3062         # Make all P fields that haven't already been constructed
3063 
3064 
3065     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3066         'Writes this packet to the supplied buffer'
3067         self._bufferstartoffset=buf.getcurrentoffset()
3068         self.__field_cl_type.writetobuffer(buf)
3069         self.__field_number.writetobuffer(buf)
3070         self.__field_datetime.writetobuffer(buf)
3071         self.__field_dunno1.writetobuffer(buf)
3072         self.__field_duration.writetobuffer(buf)
3073         self._bufferendoffset=buf.getcurrentoffset()
3074         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3075 
3076 
3077     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3078         'Reads this packet from the supplied buffer'
3079         self._bufferstartoffset=buf.getcurrentoffset()
3080         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3081         self.__field_cl_type=UINT(**{'sizeinbytes': 1})
3082         self.__field_cl_type.readfrombuffer(buf)
3083         self.__field_number=STRING(**{'sizeinbytes': 51,  'terminator': 0 })
3084         self.__field_number.readfrombuffer(buf)
3085         self.__field_datetime=DateTime2(**{'sizeinbytes': 4})
3086         self.__field_datetime.readfrombuffer(buf)
3087         self.__field_dunno1=UNKNOWN(**{'sizeinbytes': 4})
3088         self.__field_dunno1.readfrombuffer(buf)
3089         self.__field_duration=UINT(**{'sizeinbytes': 4})
3090         self.__field_duration.readfrombuffer(buf)
3091         self._bufferendoffset=buf.getcurrentoffset()
3092 
3093 
3094     def __getfield_cl_type(self):
3095         return self.__field_cl_type.getvalue()
3096 
3097     def __setfield_cl_type(self, value):
3098         if isinstance(value,UINT):
3099             self.__field_cl_type=value
3100         else:
3101             self.__field_cl_type=UINT(value,**{'sizeinbytes': 1})
3102 
3103     def __delfield_cl_type(self): del self.__field_cl_type
3104 
3105     cl_type=property(__getfield_cl_type, __setfield_cl_type, __delfield_cl_type, None)
3106 
3107     def __getfield_number(self):
3108         return self.__field_number.getvalue()
3109 
3110     def __setfield_number(self, value):
3111         if isinstance(value,STRING):
3112             self.__field_number=value
3113         else:
3114             self.__field_number=STRING(value,**{'sizeinbytes': 51,  'terminator': 0 })
3115 
3116     def __delfield_number(self): del self.__field_number
3117 
3118     number=property(__getfield_number, __setfield_number, __delfield_number, None)
3119 
3120     def __getfield_datetime(self):
3121         return self.__field_datetime.getvalue()
3122 
3123     def __setfield_datetime(self, value):
3124         if isinstance(value,DateTime2):
3125             self.__field_datetime=value
3126         else:
3127             self.__field_datetime=DateTime2(value,**{'sizeinbytes': 4})
3128 
3129     def __delfield_datetime(self): del self.__field_datetime
3130 
3131     datetime=property(__getfield_datetime, __setfield_datetime, __delfield_datetime, None)
3132 
3133     def __getfield_dunno1(self):
3134         return self.__field_dunno1.getvalue()
3135 
3136     def __setfield_dunno1(self, value):
3137         if isinstance(value,UNKNOWN):
3138             self.__field_dunno1=value
3139         else:
3140             self.__field_dunno1=UNKNOWN(value,**{'sizeinbytes': 4})
3141 
3142     def __delfield_dunno1(self): del self.__field_dunno1
3143 
3144     dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None)
3145 
3146     def __getfield_duration(self):
3147         return self.__field_duration.getvalue()
3148 
3149     def __setfield_duration(self, value):
3150         if isinstance(value,UINT):
3151             self.__field_duration=value
3152         else:
3153             self.__field_duration=UINT(value,**{'sizeinbytes': 4})
3154 
3155     def __delfield_duration(self): del self.__field_duration
3156 
3157     duration=property(__getfield_duration, __setfield_duration, __delfield_duration, None)
3158 
3159     def iscontainer(self):
3160         return True
3161 
3162     def containerelements(self):
3163         yield ('cl_type', self.__field_cl_type, None)
3164         yield ('number', self.__field_number, None)
3165         yield ('datetime', self.__field_datetime, None)
3166         yield ('dunno1', self.__field_dunno1, None)
3167         yield ('duration', self.__field_duration, None)
3168 
3169     def _valid(self):
3170         global CL_VALID_TYPE
3171         return bool(self.cl_type in CL_VALID_TYPE and self.number)
3172     valid=property(fget=_valid)
3173 
3174 
3175 
3176 
3177 class pBOOL(BaseProtogenClass):
3178     __fields=['value']
3179 
3180     def __init__(self, *args, **kwargs):
3181         dict={}
3182         # What was supplied to this function
3183         dict.update(kwargs)
3184         # Parent constructor
3185         super(pBOOL,self).__init__(**dict)
3186         if self.__class__ is pBOOL:
3187             self._update(args,dict)
3188 
3189 
3190     def getfields(self):
3191         return self.__fields
3192 
3193 
3194     def _update(self, args, kwargs):
3195         super(pBOOL,self)._update(args,kwargs)
3196         keys=kwargs.keys()
3197         for key in keys:
3198             if key in self.__fields:
3199                 setattr(self, key, kwargs[key])
3200                 del kwargs[key]
3201         # Were any unrecognized kwargs passed in?
3202         if __debug__:
3203             self._complainaboutunusedargs(pBOOL,kwargs)
3204         if len(args):
3205             dict2={'sizeinbytes': 'P'}
3206             dict2.update(kwargs)
3207             kwargs=dict2
3208             self.__field_value=BOOL(*args,**dict2)
3209         # Make all P fields that haven't already been constructed
3210         try: self.__field_value
3211         except:
3212             self.__field_value=BOOL()
3213 
3214 
3215     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3216         'Writes this packet to the supplied buffer'
3217         self._bufferstartoffset=buf.getcurrentoffset()
3218         self._bufferendoffset=buf.getcurrentoffset()
3219         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3220 
3221 
3222     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3223         'Reads this packet from the supplied buffer'
3224         self._bufferstartoffset=buf.getcurrentoffset()
3225         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3226         self._bufferendoffset=buf.getcurrentoffset()
3227 
3228 
3229     def __getfield_value(self):
3230         return self.__field_value.getvalue()
3231 
3232     def __setfield_value(self, value):
3233         if isinstance(value,BOOL):
3234             self.__field_value=value
3235         else:
3236             self.__field_value=BOOL(value,)
3237 
3238     def __delfield_value(self): del self.__field_value
3239 
3240     value=property(__getfield_value, __setfield_value, __delfield_value, None)
3241 
3242     def iscontainer(self):
3243         return True
3244 
3245     def containerelements(self):
3246         yield ('value', self.__field_value, None)
3247 
3248 
3249 
3250 
3251 class sms_header(BaseProtogenClass):
3252     __fields=['index', 'msg_len', 'callback_len', 'bitmap1', 'bitmap2', 'dunno1', 'body_len', 'file_type', 'msg_type', 'enhance_delivery', 'is_txt_msg', 'in_msg', 'sent_msg', 'draft_msg', 'body']
3253 
3254     def __init__(self, *args, **kwargs):
3255         dict={}
3256         # What was supplied to this function
3257         dict.update(kwargs)
3258         # Parent constructor
3259         super(sms_header,self).__init__(**dict)
3260         if self.__class__ is sms_header:
3261             self._update(args,dict)
3262 
3263 
3264     def getfields(self):
3265         return self.__fields
3266 
3267 
3268     def _update(self, args, kwargs):
3269         super(sms_header,self)._update(args,kwargs)
3270         keys=kwargs.keys()
3271         for key in keys:
3272             if key in self.__fields:
3273                 setattr(self, key, kwargs[key])
3274                 del kwargs[key]
3275         # Were any unrecognized kwargs passed in?
3276         if __debug__:
3277             self._complainaboutunusedargs(sms_header,kwargs)
3278         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3279         # Make all P fields that haven't already been constructed
3280 
3281 
3282     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3283         'Writes this packet to the supplied buffer'
3284         self._bufferstartoffset=buf.getcurrentoffset()
3285         self.__field_index.writetobuffer(buf)
3286         self.__field_msg_len.writetobuffer(buf)
3287         self.__field_callback_len.writetobuffer(buf)
3288         self.__field_bitmap1.writetobuffer(buf)
3289         self.__field_bitmap2.writetobuffer(buf)
3290         self.__field_dunno1.writetobuffer(buf)
3291         self.__field_body_len.writetobuffer(buf)
3292         self.__field_file_type.writetobuffer(buf)
3293         self.__field_msg_type.writetobuffer(buf)
3294         self.__field_enhance_delivery.writetobuffer(buf)
3295         self.__field_is_txt_msg.writetobuffer(buf)
3296         self.__field_in_msg.writetobuffer(buf)
3297         self.__field_sent_msg.writetobuffer(buf)
3298         self.__field_draft_msg.writetobuffer(buf)
3299         if self.is_txt_msg.value:
3300             self.__field_body.writetobuffer(buf)
3301         self._bufferendoffset=buf.getcurrentoffset()
3302         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3303 
3304 
3305     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3306         'Reads this packet from the supplied buffer'
3307         self._bufferstartoffset=buf.getcurrentoffset()
3308         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3309         self.__field_index=UINT(**{'sizeinbytes': 2})
3310         self.__field_index.readfrombuffer(buf)
3311         self.__field_msg_len=UINT(**{'sizeinbytes': 1})
3312         self.__field_msg_len.readfrombuffer(buf)
3313         self.__field_callback_len=UINT(**{'sizeinbytes': 1})
3314         self.__field_callback_len.readfrombuffer(buf)
3315         self.__field_bitmap1=UINT(**{'sizeinbytes': 1})
3316         self.__field_bitmap1.readfrombuffer(buf)
3317         self.__field_bitmap2=UINT(**{'sizeinbytes': 1})
3318         self.__field_bitmap2.readfrombuffer(buf)
3319         self.__field_dunno1=UNKNOWN(**{'sizeinbytes': 6})
3320         self.__field_dunno1.readfrombuffer(buf)
3321         self.__field_body_len=UINT(**{'sizeinbytes': 2})
3322         self.__field_body_len.readfrombuffer(buf)
3323         self.__field_file_type=UINT(**{'sizeinbytes': 2})
3324         self.__field_file_type.readfrombuffer(buf)
3325         self.__field_msg_type=UINT(**{'sizeinbytes': 1})
3326         self.__field_msg_type.readfrombuffer(buf)
3327         self.__field_enhance_delivery=UINT(**{'sizeinbytes': 1})
3328         self.__field_enhance_delivery.readfrombuffer(buf)
3329         self.__field_is_txt_msg=pBOOL(**{ 'value': self.file_type==SMS_TXT_TYPE and self.msg_type in SMS_VALID_TYPE })
3330         self.__field_is_txt_msg.readfrombuffer(buf)
3331         self.__field_in_msg=pBOOL(**{ 'value': self.msg_type==SMS_TYPE_IN })
3332         self.__field_in_msg.readfrombuffer(buf)
3333         self.__field_sent_msg=pBOOL(**{ 'value': self.msg_type==SMS_TYPE_SENT })
3334         self.__field_sent_msg.readfrombuffer(buf)
3335         self.__field_draft_msg=pBOOL(**{ 'value': self.msg_type==SMS_TYPE_DRAFT })
3336         self.__field_draft_msg.readfrombuffer(buf)
3337         if self.is_txt_msg.value:
3338             self.__field_body=sms_body(**{            'msg_len': self.msg_len,            'has_callback': self.bitmap2 & SMS_FLG2_CALLBACK,            'has_priority': self.bitmap2 & SMS_FLG2_PRIORITY,            'has_1byte': self.bitmap2 & SMS_FLG2_SOMETHING,            'has_1byte2': self.bitmap2 & SMS_FLG2_MSG,            'has_40bytes': self.bitmap1 & SMS_FLG1_HAS40 })
3339             self.__field_body.readfrombuffer(buf)
3340         self._bufferendoffset=buf.getcurrentoffset()
3341 
3342 
3343     def __getfield_index(self):
3344         return self.__field_index.getvalue()
3345 
3346     def __setfield_index(self, value):
3347         if isinstance(value,UINT):
3348             self.__field_index=value
3349         else:
3350             self.__field_index=UINT(value,**{'sizeinbytes': 2})
3351 
3352     def __delfield_index(self): del self.__field_index
3353 
3354     index=property(__getfield_index, __setfield_index, __delfield_index, None)
3355 
3356     def __getfield_msg_len(self):
3357         return self.__field_msg_len.getvalue()
3358 
3359     def __setfield_msg_len(self, value):
3360         if isinstance(value,UINT):
3361             self.__field_msg_len=value
3362         else:
3363             self.__field_msg_len=UINT(value,**{'sizeinbytes': 1})
3364 
3365     def __delfield_msg_len(self): del self.__field_msg_len
3366 
3367     msg_len=property(__getfield_msg_len, __setfield_msg_len, __delfield_msg_len, None)
3368 
3369     def __getfield_callback_len(self):
3370         return self.__field_callback_len.getvalue()
3371 
3372     def __setfield_callback_len(self, value):
3373         if isinstance(value,UINT):
3374             self.__field_callback_len=value
3375         else:
3376             self.__field_callback_len=UINT(value,**{'sizeinbytes': 1})
3377 
3378     def __delfield_callback_len(self): del self.__field_callback_len
3379 
3380     callback_len=property(__getfield_callback_len, __setfield_callback_len, __delfield_callback_len, None)
3381 
3382     def __getfield_bitmap1(self):
3383         return self.__field_bitmap1.getvalue()
3384 
3385     def __setfield_bitmap1(self, value):
3386         if isinstance(value,UINT):
3387             self.__field_bitmap1=value
3388         else:
3389             self.__field_bitmap1=UINT(value,**{'sizeinbytes': 1})
3390 
3391     def __delfield_bitmap1(self): del self.__field_bitmap1
3392 
3393     bitmap1=property(__getfield_bitmap1, __setfield_bitmap1, __delfield_bitmap1, None)
3394 
3395     def __getfield_bitmap2(self):
3396         return self.__field_bitmap2.getvalue()
3397 
3398     def __setfield_bitmap2(self, value):
3399         if isinstance(value,UINT):
3400             self.__field_bitmap2=value
3401         else:
3402             self.__field_bitmap2=UINT(value,**{'sizeinbytes': 1})
3403 
3404     def __delfield_bitmap2(self): del self.__field_bitmap2
3405 
3406     bitmap2=property(__getfield_bitmap2, __setfield_bitmap2, __delfield_bitmap2, None)
3407 
3408     def __getfield_dunno1(self):
3409         return self.__field_dunno1.getvalue()
3410 
3411     def __setfield_dunno1(self, value):
3412         if isinstance(value,UNKNOWN):
3413             self.__field_dunno1=value
3414         else:
3415             self.__field_dunno1=UNKNOWN(value,**{'sizeinbytes': 6})
3416 
3417     def __delfield_dunno1(self): del self.__field_dunno1
3418 
3419     dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None)
3420 
3421     def __getfield_body_len(self):
3422         return self.__field_body_len.getvalue()
3423 
3424     def __setfield_body_len(self, value):
3425         if isinstance(value,UINT):
3426             self.__field_body_len=value
3427         else:
3428             self.__field_body_len=UINT(value,**{'sizeinbytes': 2})
3429 
3430     def __delfield_body_len(self): del self.__field_body_len
3431 
3432     body_len=property(__getfield_body_len, __setfield_body_len, __delfield_body_len, None)
3433 
3434     def __getfield_file_type(self):
3435         return self.__field_file_type.getvalue()
3436 
3437     def __setfield_file_type(self, value):
3438         if isinstance(value,UINT):
3439             self.__field_file_type=value
3440         else:
3441             self.__field_file_type=UINT(value,**{'sizeinbytes': 2})
3442 
3443     def __delfield_file_type(self): del self.__field_file_type
3444 
3445     file_type=property(__getfield_file_type, __setfield_file_type, __delfield_file_type, None)
3446 
3447     def __getfield_msg_type(self):
3448         return self.__field_msg_type.getvalue()
3449 
3450     def __setfield_msg_type(self, value):
3451         if isinstance(value,UINT):
3452             self.__field_msg_type=value
3453         else:
3454             self.__field_msg_type=UINT(value,**{'sizeinbytes': 1})
3455 
3456     def __delfield_msg_type(self): del self.__field_msg_type
3457 
3458     msg_type=property(__getfield_msg_type, __setfield_msg_type, __delfield_msg_type, None)
3459 
3460     def __getfield_enhance_delivery(self):
3461         return self.__field_enhance_delivery.getvalue()
3462 
3463     def __setfield_enhance_delivery(self, value):
3464         if isinstance(value,UINT):
3465             self.__field_enhance_delivery=value
3466         else:
3467             self.__field_enhance_delivery=UINT(value,**{'sizeinbytes': 1})
3468 
3469     def __delfield_enhance_delivery(self): del self.__field_enhance_delivery
3470 
3471     enhance_delivery=property(__getfield_enhance_delivery, __setfield_enhance_delivery, __delfield_enhance_delivery, None)
3472 
3473     def __getfield_is_txt_msg(self):
3474         return self.__field_is_txt_msg.getvalue()
3475 
3476     def __setfield_is_txt_msg(self, value):
3477         if isinstance(value,pBOOL):
3478             self.__field_is_txt_msg=value
3479         else:
3480             self.__field_is_txt_msg=pBOOL(value,**{ 'value': self.file_type==SMS_TXT_TYPE and self.msg_type in SMS_VALID_TYPE })
3481 
3482     def __delfield_is_txt_msg(self): del self.__field_is_txt_msg
3483 
3484     is_txt_msg=property(__getfield_is_txt_msg, __setfield_is_txt_msg, __delfield_is_txt_msg, None)
3485 
3486     def __getfield_in_msg(self):
3487         return self.__field_in_msg.getvalue()
3488 
3489     def __setfield_in_msg(self, value):
3490         if isinstance(value,pBOOL):
3491             self.__field_in_msg=value
3492         else:
3493             self.__field_in_msg=pBOOL(value,**{ 'value': self.msg_type==SMS_TYPE_IN })
3494 
3495     def __delfield_in_msg(self): del self.__field_in_msg
3496 
3497     in_msg=property(__getfield_in_msg, __setfield_in_msg, __delfield_in_msg, None)
3498 
3499     def __getfield_sent_msg(self):
3500         return self.__field_sent_msg.getvalue()
3501 
3502     def __setfield_sent_msg(self, value):
3503         if isinstance(value,pBOOL):
3504             self.__field_sent_msg=value
3505         else:
3506             self.__field_sent_msg=pBOOL(value,**{ 'value': self.msg_type==SMS_TYPE_SENT })
3507 
3508     def __delfield_sent_msg(self): del self.__field_sent_msg
3509 
3510     sent_msg=property(__getfield_sent_msg, __setfield_sent_msg, __delfield_sent_msg, None)
3511 
3512     def __getfield_draft_msg(self):
3513         return self.__field_draft_msg.getvalue()
3514 
3515     def __setfield_draft_msg(self, value):
3516         if isinstance(value,pBOOL):
3517             self.__field_draft_msg=value
3518         else:
3519             self.__field_draft_msg=pBOOL(value,**{ 'value': self.msg_type==SMS_TYPE_DRAFT })
3520 
3521     def __delfield_draft_msg(self): del self.__field_draft_msg
3522 
3523     draft_msg=property(__getfield_draft_msg, __setfield_draft_msg, __delfield_draft_msg, None)
3524 
3525     def __getfield_body(self):
3526         return self.__field_body.getvalue()
3527 
3528     def __setfield_body(self, value):
3529         if isinstance(value,sms_body):
3530             self.__field_body=value
3531         else:
3532             self.__field_body=sms_body(value,**{            'msg_len': self.msg_len,            'has_callback': self.bitmap2 & SMS_FLG2_CALLBACK,            'has_priority': self.bitmap2 & SMS_FLG2_PRIORITY,            'has_1byte': self.bitmap2 & SMS_FLG2_SOMETHING,            'has_1byte2': self.bitmap2 & SMS_FLG2_MSG,            'has_40bytes': self.bitmap1 & SMS_FLG1_HAS40 })
3533 
3534     def __delfield_body(self): del self.__field_body
3535 
3536     body=property(__getfield_body, __setfield_body, __delfield_body, None)
3537 
3538     def iscontainer(self):
3539         return True
3540 
3541     def containerelements(self):
3542         yield ('index', self.__field_index, None)
3543         yield ('msg_len', self.__field_msg_len, None)
3544         yield ('callback_len', self.__field_callback_len, None)
3545         yield ('bitmap1', self.__field_bitmap1, None)
3546         yield ('bitmap2', self.__field_bitmap2, None)
3547         yield ('dunno1', self.__field_dunno1, None)
3548         yield ('body_len', self.__field_body_len, None)
3549         yield ('file_type', self.__field_file_type, None)
3550         yield ('msg_type', self.__field_msg_type, None)
3551         yield ('enhance_delivery', self.__field_enhance_delivery, None)
3552         yield ('is_txt_msg', self.__field_is_txt_msg, None)
3553         yield ('in_msg', self.__field_in_msg, None)
3554         yield ('sent_msg', self.__field_sent_msg, None)
3555         yield ('draft_msg', self.__field_draft_msg, None)
3556         if self.is_txt_msg.value:
3557             yield ('body', self.__field_body, None)
3558 
3559 
3560 
3561 
3562 class sms_msg_stat_list(BaseProtogenClass):
3563     __fields=['status']
3564 
3565     def __init__(self, *args, **kwargs):
3566         dict={}
3567         # What was supplied to this function
3568         dict.update(kwargs)
3569         # Parent constructor
3570         super(sms_msg_stat_list,self).__init__(**dict)
3571         if self.__class__ is sms_msg_stat_list:
3572             self._update(args,dict)
3573 
3574 
3575     def getfields(self):
3576         return self.__fields
3577 
3578 
3579     def _update(self, args, kwargs):
3580         super(sms_msg_stat_list,self)._update(args,kwargs)
3581         keys=kwargs.keys()
3582         for key in keys:
3583             if key in self.__fields:
3584                 setattr(self, key, kwargs[key])
3585                 del kwargs[key]
3586         # Were any unrecognized kwargs passed in?
3587         if __debug__:
3588             self._complainaboutunusedargs(sms_msg_stat_list,kwargs)
3589         if len(args):
3590             dict2={'sizeinbytes': 1}
3591             dict2.update(kwargs)
3592             kwargs=dict2
3593             self.__field_status=UINT(*args,**dict2)
3594         # Make all P fields that haven't already been constructed
3595 
3596 
3597     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3598         'Writes this packet to the supplied buffer'
3599         self._bufferstartoffset=buf.getcurrentoffset()
3600         self.__field_status.writetobuffer(buf)
3601         self._bufferendoffset=buf.getcurrentoffset()
3602         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3603 
3604 
3605     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3606         'Reads this packet from the supplied buffer'
3607         self._bufferstartoffset=buf.getcurrentoffset()
3608         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3609         self.__field_status=UINT(**{'sizeinbytes': 1})
3610         self.__field_status.readfrombuffer(buf)
3611         self._bufferendoffset=buf.getcurrentoffset()
3612 
3613 
3614     def __getfield_status(self):
3615         return self.__field_status.getvalue()
3616 
3617     def __setfield_status(self, value):
3618         if isinstance(value,UINT):
3619             self.__field_status=value
3620         else:
3621             self.__field_status=UINT(value,**{'sizeinbytes': 1})
3622 
3623     def __delfield_status(self): del self.__field_status
3624 
3625     status=property(__getfield_status, __setfield_status, __delfield_status, None)
3626 
3627     def iscontainer(self):
3628         return True
3629 
3630     def containerelements(self):
3631         yield ('status', self.__field_status, None)
3632 
3633 
3634 
3635 
3636 class sms_datetime_list(BaseProtogenClass):
3637     __fields=['datetime', 'dunno']
3638 
3639     def __init__(self, *args, **kwargs):
3640         dict={}
3641         # What was supplied to this function
3642         dict.update(kwargs)
3643         # Parent constructor
3644         super(sms_datetime_list,self).__init__(**dict)
3645         if self.__class__ is sms_datetime_list:
3646             self._update(args,dict)
3647 
3648 
3649     def getfields(self):
3650         return self.__fields
3651 
3652 
3653     def _update(self, args, kwargs):
3654         super(sms_datetime_list,self)._update(args,kwargs)
3655         keys=kwargs.keys()
3656         for key in keys:
3657             if key in self.__fields:
3658                 setattr(self, key, kwargs[key])
3659                 del kwargs[key]
3660         # Were any unrecognized kwargs passed in?
3661         if __debug__:
3662             self._complainaboutunusedargs(sms_datetime_list,kwargs)
3663         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3664         # Make all P fields that haven't already been constructed
3665 
3666 
3667     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3668         'Writes this packet to the supplied buffer'
3669         self._bufferstartoffset=buf.getcurrentoffset()
3670         self.__field_datetime.writetobuffer(buf)
3671         self.__field_dunno.writetobuffer(buf)
3672         self._bufferendoffset=buf.getcurrentoffset()
3673         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3674 
3675 
3676     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3677         'Reads this packet from the supplied buffer'
3678         self._bufferstartoffset=buf.getcurrentoffset()
3679         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3680         self.__field_datetime=DateTime2(**{'sizeinbytes': 4})
3681         self.__field_datetime.readfrombuffer(buf)
3682         self.__field_dunno=UNKNOWN(**{'sizeinbytes': 4})
3683         self.__field_dunno.readfrombuffer(buf)
3684         self._bufferendoffset=buf.getcurrentoffset()
3685 
3686 
3687     def __getfield_datetime(self):
3688         return self.__field_datetime.getvalue()
3689 
3690     def __setfield_datetime(self, value):
3691         if isinstance(value,DateTime2):
3692             self.__field_datetime=value
3693         else:
3694             self.__field_datetime=DateTime2(value,**{'sizeinbytes': 4})
3695 
3696     def __delfield_datetime(self): del self.__field_datetime
3697 
3698     datetime=property(__getfield_datetime, __setfield_datetime, __delfield_datetime, None)
3699 
3700     def __getfield_dunno(self):
3701         return self.__field_dunno.getvalue()
3702 
3703     def __setfield_dunno(self, value):
3704         if isinstance(value,UNKNOWN):
3705             self.__field_dunno=value
3706         else:
3707             self.__field_dunno=UNKNOWN(value,**{'sizeinbytes': 4})
3708 
3709     def __delfield_dunno(self): del self.__field_dunno
3710 
3711     dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, None)
3712 
3713     def iscontainer(self):
3714         return True
3715 
3716     def containerelements(self):
3717         yield ('datetime', self.__field_datetime, None)
3718         yield ('dunno', self.__field_dunno, None)
3719 
3720 
3721 
3722 
3723 class sms_delivered_datetime(BaseProtogenClass):
3724     __fields=['datetime', 'dunno']
3725 
3726     def __init__(self, *args, **kwargs):
3727         dict={}
3728         # What was supplied to this function
3729         dict.update(kwargs)
3730         # Parent constructor
3731         super(sms_delivered_datetime,self).__init__(**dict)
3732         if self.__class__ is sms_delivered_datetime:
3733             self._update(args,dict)
3734 
3735 
3736     def getfields(self):
3737         return self.__fields
3738 
3739 
3740     def _update(self, args, kwargs):
3741         super(sms_delivered_datetime,self)._update(args,kwargs)
3742         keys=kwargs.keys()
3743         for key in keys:
3744             if key in self.__fields:
3745                 setattr(self, key, kwargs[key])
3746                 del kwargs[key]
3747         # Were any unrecognized kwargs passed in?
3748         if __debug__:
3749             self._complainaboutunusedargs(sms_delivered_datetime,kwargs)
3750         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3751         # Make all P fields that haven't already been constructed
3752 
3753 
3754     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3755         'Writes this packet to the supplied buffer'
3756         self._bufferstartoffset=buf.getcurrentoffset()
3757         self.__field_datetime.writetobuffer(buf)
3758         self.__field_dunno.writetobuffer(buf)
3759         self._bufferendoffset=buf.getcurrentoffset()
3760         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3761 
3762 
3763     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3764         'Reads this packet from the supplied buffer'
3765         self._bufferstartoffset=buf.getcurrentoffset()
3766         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3767         self.__field_datetime=LIST(**{ 'elementclass': sms_datetime_list,             'length': 10 })
3768         self.__field_datetime.readfrombuffer(buf)
3769         self.__field_dunno=UNKNOWN(**{'sizeinbytes': 20})
3770         self.__field_dunno.readfrombuffer(buf)
3771         self._bufferendoffset=buf.getcurrentoffset()
3772 
3773 
3774     def __getfield_datetime(self):
3775         return self.__field_datetime.getvalue()
3776 
3777     def __setfield_datetime(self, value):
3778         if isinstance(value,LIST):
3779             self.__field_datetime=value
3780         else:
3781             self.__field_datetime=LIST(value,**{ 'elementclass': sms_datetime_list,             'length': 10 })
3782 
3783     def __delfield_datetime(self): del self.__field_datetime
3784 
3785     datetime=property(__getfield_datetime, __setfield_datetime, __delfield_datetime, None)
3786 
3787     def __getfield_dunno(self):
3788         return self.__field_dunno.getvalue()
3789 
3790     def __setfield_dunno(self, value):
3791         if isinstance(value,UNKNOWN):
3792             self.__field_dunno=value
3793         else:
3794             self.__field_dunno=UNKNOWN(value,**{'sizeinbytes': 20})
3795 
3796     def __delfield_dunno(self): del self.__field_dunno
3797 
3798     dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, None)
3799 
3800     def iscontainer(self):
3801         return True
3802 
3803     def containerelements(self):
3804         yield ('datetime', self.__field_datetime, None)
3805         yield ('dunno', self.__field_dunno, None)
3806 
3807 
3808 
3809 
3810 class sms_body(BaseProtogenClass):
3811     __fields=['msg_len', 'has_callback', 'has_priority', 'has_1byte', 'has_1byte2', 'has_40bytes', 'dunno1', 'msg', 'dunno2', 'callback_len', 'callback', 'priority', 'dunno3', 'dunno4', 'datetime', 'dunno5', 'addr_len0', 'addr_len1', 'addr_len2', 'addr_len3', 'addr_len4', 'addr_len5', 'addr_len6', 'addr_len7', 'addr_len8', 'addr_len9', 'addr0', 'addr1', 'addr2', 'addr3', 'addr4', 'addr5', 'addr6', 'addr7', 'addr8', 'addr9', 'dunno6', 'dunno7', 'dunno8', 'dunno9', 'msg_stat']
3812 
3813     def __init__(self, *args, **kwargs):
3814         dict={}
3815         # What was supplied to this function
3816         dict.update(kwargs)
3817         # Parent constructor
3818         super(sms_body,self).__init__(**dict)
3819         if self.__class__ is sms_body:
3820             self._update(args,dict)
3821 
3822 
3823     def getfields(self):
3824         return self.__fields
3825 
3826 
3827     def _update(self, args, kwargs):
3828         super(sms_body,self)._update(args,kwargs)
3829         keys=kwargs.keys()
3830         for key in keys:
3831             if key in self.__fields:
3832                 setattr(self, key, kwargs[key])
3833                 del kwargs[key]
3834         # Were any unrecognized kwargs passed in?
3835         if __debug__:
3836             self._complainaboutunusedargs(sms_body,kwargs)
3837         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3838         # Make all P fields that haven't already been constructed
3839         try: self.__field_msg_len
3840         except:
3841             self.__field_msg_len=UINT()
3842         try: self.__field_has_callback
3843         except:
3844             self.__field_has_callback=BOOL(**{ 'default': True })
3845         try: self.__field_has_priority
3846         except:
3847             self.__field_has_priority=BOOL(**{ 'default': False })
3848         try: self.__field_has_1byte
3849         except:
3850             self.__field_has_1byte=BOOL(**{ 'default': False })
3851         try: self.__field_has_1byte2
3852         except:
3853             self.__field_has_1byte2=BOOL(**{ 'default': True })
3854         try: self.__field_has_40bytes
3855         except:
3856             self.__field_has_40bytes=BOOL(**{ 'default': False })
3857 
3858 
3859     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3860         'Writes this packet to the supplied buffer'
3861         self._bufferstartoffset=buf.getcurrentoffset()
3862         self.__field_dunno1.writetobuffer(buf)
3863         self.__field_msg.writetobuffer(buf)
3864         if self.has_callback:
3865             self.__field_dunno2.writetobuffer(buf)
3866             self.__field_callback_len.writetobuffer(buf)
3867             self.__field_callback.writetobuffer(buf)
3868         if self.has_priority:
3869             self.__field_priority.writetobuffer(buf)
3870         if self.has_1byte:
3871             self.__field_dunno3.writetobuffer(buf)
3872         self.__field_dunno4.writetobuffer(buf)
3873         self.__field_datetime.writetobuffer(buf)
3874         self.__field_dunno5.writetobuffer(buf)
3875         self.__field_addr_len0.writetobuffer(buf)
3876         self.__field_addr_len1.writetobuffer(buf)
3877         self.__field_addr_len2.writetobuffer(buf)
3878         self.__field_addr_len3.writetobuffer(buf)
3879         self.__field_addr_len4.writetobuffer(buf)
3880         self.__field_addr_len5.writetobuffer(buf)
3881         self.__field_addr_len6.writetobuffer(buf)
3882         self.__field_addr_len7.writetobuffer(buf)
3883         self.__field_addr_len8.writetobuffer(buf)
3884         self.__field_addr_len9.writetobuffer(buf)
3885         if self.addr_len0:
3886             self.__field_addr0.writetobuffer(buf)
3887         if self.addr_len1:
3888             self.__field_addr1.writetobuffer(buf)
3889         if self.addr_len2:
3890             self.__field_addr2.writetobuffer(buf)
3891         if self.addr_len3:
3892             self.__field_addr3.writetobuffer(buf)
3893         if self.addr_len4:
3894             self.__field_addr4.writetobuffer(buf)
3895         if self.addr_len5:
3896             self.__field_addr5.writetobuffer(buf)
3897         if self.addr_len6:
3898             self.__field_addr6.writetobuffer(buf)
3899         if self.addr_len7:
3900             self.__field_addr7.writetobuffer(buf)
3901         if self.addr_len8:
3902             self.__field_addr8.writetobuffer(buf)
3903         if self.addr_len9:
3904             self.__field_addr9.writetobuffer(buf)
3905         if not self.has_1byte and self.has_1byte2:
3906             self.__field_dunno6.writetobuffer(buf)
3907         if self.has_1byte2:
3908             self.__field_dunno7.writetobuffer(buf)
3909         self.__field_dunno8.writetobuffer(buf)
3910         if self.has_40bytes:
3911             self.__field_dunno9.writetobuffer(buf)
3912         self.__field_msg_stat.writetobuffer(buf)
3913         self._bufferendoffset=buf.getcurrentoffset()
3914         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3915 
3916 
3917     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3918         'Reads this packet from the supplied buffer'
3919         self._bufferstartoffset=buf.getcurrentoffset()
3920         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3921         self.__field_dunno1=UNKNOWN(**{'sizeinbytes': 54})
3922         self.__field_dunno1.readfrombuffer(buf)
3923         self.__field_msg=USTRING(**{ 'sizeinbytes': self.msg_len,                'encoding': ENCODING,                'terminator': None })
3924         self.__field_msg.readfrombuffer(buf)
3925         if self.has_callback:
3926             self.__field_dunno2=UNKNOWN(**{'sizeinbytes': 3})
3927             self.__field_dunno2.readfrombuffer(buf)
3928             self.__field_callback_len=UINT(**{'sizeinbytes': 1})
3929             self.__field_callback_len.readfrombuffer(buf)
3930             self.__field_callback=STRING(**{ 'sizeinbytes': self.callback_len,                   'terminator': None })
3931             self.__field_callback.readfrombuffer(buf)
3932         if self.has_priority:
3933             self.__field_priority=UINT(**{'sizeinbytes': 1})
3934             self.__field_priority.readfrombuffer(buf)
3935         if self.has_1byte:
3936             self.__field_dunno3=UNKNOWN(**{'sizeinbytes': 1})
3937             self.__field_dunno3.readfrombuffer(buf)
3938         self.__field_dunno4=UNKNOWN(**{'sizeinbytes': 40})
3939         self.__field_dunno4.readfrombuffer(buf)
3940         self.__field_datetime=DateTime1(**{'sizeinbytes': 4})
3941         self.__field_datetime.readfrombuffer(buf)
3942         self.__field_dunno5=UNKNOWN(**{'sizeinbytes': 17})
3943         self.__field_dunno5.readfrombuffer(buf)
3944         self.__field_addr_len0=UINT(**{'sizeinbytes': 1})
3945         self.__field_addr_len0.readfrombuffer(buf)
3946         self.__field_addr_len1=UINT(**{'sizeinbytes': 1})
3947         self.__field_addr_len1.readfrombuffer(buf)
3948         self.__field_addr_len2=UINT(**{'sizeinbytes': 1})
3949         self.__field_addr_len2.readfrombuffer(buf)
3950         self.__field_addr_len3=UINT(**{'sizeinbytes': 1})
3951         self.__field_addr_len3.readfrombuffer(buf)
3952         self.__field_addr_len4=UINT(**{'sizeinbytes': 1})
3953         self.__field_addr_len4.readfrombuffer(buf)
3954         self.__field_addr_len5=UINT(**{'sizeinbytes': 1})
3955         self.__field_addr_len5.readfrombuffer(buf)
3956         self.__field_addr_len6=UINT(**{'sizeinbytes': 1})
3957         self.__field_addr_len6.readfrombuffer(buf)
3958         self.__field_addr_len7=UINT(**{'sizeinbytes': 1})
3959         self.__field_addr_len7.readfrombuffer(buf)
3960         self.__field_addr_len8=UINT(**{'sizeinbytes': 1})
3961         self.__field_addr_len8.readfrombuffer(buf)
3962         self.__field_addr_len9=UINT(**{'sizeinbytes': 1})
3963         self.__field_addr_len9.readfrombuffer(buf)
3964         if self.addr_len0:
3965             self.__field_addr0=STRING(**{ 'sizeinbytes': self.addr_len0,                   'terminator': None })
3966             self.__field_addr0.readfrombuffer(buf)
3967         if self.addr_len1:
3968             self.__field_addr1=STRING(**{ 'sizeinbytes': self.addr_len1,                   'terminator': None })
3969             self.__field_addr1.readfrombuffer(buf)
3970         if self.addr_len2:
3971             self.__field_addr2=STRING(**{ 'sizeinbytes': self.addr_len2,                   'terminator': None })
3972             self.__field_addr2.readfrombuffer(buf)
3973         if self.addr_len3:
3974             self.__field_addr3=STRING(**{ 'sizeinbytes': self.addr_len3,                   'terminator': None })
3975             self.__field_addr3.readfrombuffer(buf)
3976         if self.addr_len4:
3977             self.__field_addr4=STRING(**{ 'sizeinbytes': self.addr_len4,                   'terminator': None })
3978             self.__field_addr4.readfrombuffer(buf)
3979         if self.addr_len5:
3980             self.__field_addr5=STRING(**{ 'sizeinbytes': self.addr_len5,                   'terminator': None })
3981             self.__field_addr5.readfrombuffer(buf)
3982         if self.addr_len6:
3983             self.__field_addr6=STRING(**{ 'sizeinbytes': self.addr_len6,                   'terminator': None })
3984             self.__field_addr6.readfrombuffer(buf)
3985         if self.addr_len7:
3986             self.__field_addr7=STRING(**{ 'sizeinbytes': self.addr_len7,                   'terminator': None })
3987             self.__field_addr7.readfrombuffer(buf)
3988         if self.addr_len8:
3989             self.__field_addr8=STRING(**{ 'sizeinbytes': self.addr_len8,                   'terminator': None })
3990             self.__field_addr8.readfrombuffer(buf)
3991         if self.addr_len9:
3992             self.__field_addr9=STRING(**{ 'sizeinbytes': self.addr_len9,                   'terminator': None })
3993             self.__field_addr9.readfrombuffer(buf)
3994         if not self.has_1byte and self.has_1byte2:
3995             self.__field_dunno6=UNKNOWN(**{'sizeinbytes': 1})
3996             self.__field_dunno6.readfrombuffer(buf)
3997         if self.has_1byte2:
3998             self.__field_dunno7=UNKNOWN(**{'sizeinbytes': 1})
3999             self.__field_dunno7.readfrombuffer(buf)
4000         self.__field_dunno8=UNKNOWN(**{'sizeinbytes': 81})
4001         self.__field_dunno8.readfrombuffer(buf)
4002         if self.has_40bytes:
4003             self.__field_dunno9=UNKNOWN(**{'sizeinbytes': 40})
4004             self.__field_dunno9.readfrombuffer(buf)
4005         self.__field_msg_stat=LIST(**{ 'elementclass': sms_msg_stat_list,             'length': 10 })
4006         self.__field_msg_stat.readfrombuffer(buf)
4007         self._bufferendoffset=buf.getcurrentoffset()
4008 
4009 
4010     def __getfield_msg_len(self):
4011         return self.__field_msg_len.getvalue()
4012 
4013     def __setfield_msg_len(self, value):
4014         if isinstance(value,UINT):
4015             self.__field_msg_len=value
4016         else:
4017             self.__field_msg_len=UINT(value,)
4018 
4019     def __delfield_msg_len(self): del self.__field_msg_len
4020 
4021     msg_len=property(__getfield_msg_len, __setfield_msg_len, __delfield_msg_len, None)
4022 
4023     def __getfield_has_callback(self):
4024         try: self.__field_has_callback
4025         except:
4026             self.__field_has_callback=BOOL(**{ 'default': True })
4027         return self.__field_has_callback.getvalue()
4028 
4029     def __setfield_has_callback(self, value):
4030         if isinstance(value,BOOL):
4031             self.__field_has_callback=value
4032         else:
4033             self.__field_has_callback=BOOL(value,**{ 'default': True })
4034 
4035     def __delfield_has_callback(self): del self.__field_has_callback
4036 
4037     has_callback=property(__getfield_has_callback, __setfield_has_callback, __delfield_has_callback, None)
4038 
4039     def __getfield_has_priority(self):
4040         try: self.__field_has_priority
4041         except:
4042             self.__field_has_priority=BOOL(**{ 'default': False })
4043         return self.__field_has_priority.getvalue()
4044 
4045     def __setfield_has_priority(self, value):
4046         if isinstance(value,BOOL):
4047             self.__field_has_priority=value
4048         else:
4049             self.__field_has_priority=BOOL(value,**{ 'default': False })
4050 
4051     def __delfield_has_priority(self): del self.__field_has_priority
4052 
4053     has_priority=property(__getfield_has_priority, __setfield_has_priority, __delfield_has_priority, None)
4054 
4055     def __getfield_has_1byte(self):
4056         try: self.__field_has_1byte
4057         except:
4058             self.__field_has_1byte=BOOL(**{ 'default': False })
4059         return self.__field_has_1byte.getvalue()
4060 
4061     def __setfield_has_1byte(self, value):
4062         if isinstance(value,BOOL):
4063             self.__field_has_1byte=value
4064         else:
4065             self.__field_has_1byte=BOOL(value,**{ 'default': False })
4066 
4067     def __delfield_has_1byte(self): del self.__field_has_1byte
4068 
4069     has_1byte=property(__getfield_has_1byte, __setfield_has_1byte, __delfield_has_1byte, None)
4070 
4071     def __getfield_has_1byte2(self):
4072         try: self.__field_has_1byte2
4073         except:
4074             self.__field_has_1byte2=BOOL(**{ 'default': True })
4075         return self.__field_has_1byte2.getvalue()
4076 
4077     def __setfield_has_1byte2(self, value):
4078         if isinstance(value,BOOL):
4079             self.__field_has_1byte2=value
4080         else:
4081             self.__field_has_1byte2=BOOL(value,**{ 'default': True })
4082 
4083     def __delfield_has_1byte2(self): del self.__field_has_1byte2
4084 
4085     has_1byte2=property(__getfield_has_1byte2, __setfield_has_1byte2, __delfield_has_1byte2, None)
4086 
4087     def __getfield_has_40bytes(self):
4088         try: self.__field_has_40bytes
4089         except:
4090             self.__field_has_40bytes=BOOL(**{ 'default': False })
4091         return self.__field_has_40bytes.getvalue()
4092 
4093     def __setfield_has_40bytes(self, value):
4094         if isinstance(value,BOOL):
4095             self.__field_has_40bytes=value
4096         else:
4097             self.__field_has_40bytes=BOOL(value,**{ 'default': False })
4098 
4099     def __delfield_has_40bytes(self): del self.__field_has_40bytes
4100 
4101     has_40bytes=property(__getfield_has_40bytes, __setfield_has_40bytes, __delfield_has_40bytes, None)
4102 
4103     def __getfield_dunno1(self):
4104         return self.__field_dunno1.getvalue()
4105 
4106     def __setfield_dunno1(self, value):
4107         if isinstance(value,UNKNOWN):
4108             self.__field_dunno1=value
4109         else:
4110             self.__field_dunno1=UNKNOWN(value,**{'sizeinbytes': 54})
4111 
4112     def __delfield_dunno1(self): del self.__field_dunno1
4113 
4114     dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None)
4115 
4116     def __getfield_msg(self):
4117         return self.__field_msg.getvalue()
4118 
4119     def __setfield_msg(self, value):
4120         if isinstance(value,USTRING):
4121             self.__field_msg=value
4122         else:
4123             self.__field_msg=USTRING(value,**{ 'sizeinbytes': self.msg_len,                'encoding': ENCODING,                'terminator': None })
4124 
4125     def __delfield_msg(self): del self.__field_msg
4126 
4127     msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None)
4128 
4129     def __getfield_dunno2(self):
4130         return self.__field_dunno2.getvalue()
4131 
4132     def __setfield_dunno2(self, value):
4133         if isinstance(value,UNKNOWN):
4134             self.__field_dunno2=value
4135         else:
4136             self.__field_dunno2=UNKNOWN(value,**{'sizeinbytes': 3})
4137 
4138     def __delfield_dunno2(self): del self.__field_dunno2
4139 
4140     dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None)
4141 
4142     def __getfield_callback_len(self):
4143         return self.__field_callback_len.getvalue()
4144 
4145     def __setfield_callback_len(self, value):
4146         if isinstance(value,UINT):
4147             self.__field_callback_len=value
4148         else:
4149             self.__field_callback_len=UINT(value,**{'sizeinbytes': 1})
4150 
4151     def __delfield_callback_len(self): del self.__field_callback_len
4152 
4153     callback_len=property(__getfield_callback_len, __setfield_callback_len, __delfield_callback_len, None)
4154 
4155     def __getfield_callback(self):
4156         return self.__field_callback.getvalue()
4157 
4158     def __setfield_callback(self, value):
4159         if isinstance(value,STRING):
4160             self.__field_callback=value
4161         else:
4162             self.__field_callback=STRING(value,**{ 'sizeinbytes': self.callback_len,                   'terminator': None })
4163 
4164     def __delfield_callback(self): del self.__field_callback
4165 
4166     callback=property(__getfield_callback, __setfield_callback, __delfield_callback, None)
4167 
4168     def __getfield_priority(self):
4169         return self.__field_priority.getvalue()
4170 
4171     def __setfield_priority(self, value):
4172         if isinstance(value,UINT):
4173             self.__field_priority=value
4174         else:
4175             self.__field_priority=UINT(value,**{'sizeinbytes': 1})
4176 
4177     def __delfield_priority(self): del self.__field_priority
4178 
4179     priority=property(__getfield_priority, __setfield_priority, __delfield_priority, None)
4180 
4181     def __getfield_dunno3(self):
4182         return self.__field_dunno3.getvalue()
4183 
4184     def __setfield_dunno3(self, value):
4185         if isinstance(value,UNKNOWN):
4186             self.__field_dunno3=value
4187         else:
4188             self.__field_dunno3=UNKNOWN(value,**{'sizeinbytes': 1})
4189 
4190     def __delfield_dunno3(self): del self.__field_dunno3
4191 
4192     dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None)
4193 
4194     def __getfield_dunno4(self):
4195         return self.__field_dunno4.getvalue()
4196 
4197     def __setfield_dunno4(self, value):
4198         if isinstance(value,UNKNOWN):
4199             self.__field_dunno4=value
4200         else:
4201             self.__field_dunno4=UNKNOWN(value,**{'sizeinbytes': 40})
4202 
4203     def __delfield_dunno4(self): del self.__field_dunno4
4204 
4205     dunno4=property(__getfield_dunno4, __setfield_dunno4, __delfield_dunno4, None)
4206 
4207     def __getfield_datetime(self):
4208         return self.__field_datetime.getvalue()
4209 
4210     def __setfield_datetime(self, value):
4211         if isinstance(value,DateTime1):
4212             self.__field_datetime=value
4213         else:
4214             self.__field_datetime=DateTime1(value,**{'sizeinbytes': 4})
4215 
4216     def __delfield_datetime(self): del self.__field_datetime
4217 
4218     datetime=property(__getfield_datetime, __setfield_datetime, __delfield_datetime, None)
4219 
4220     def __getfield_dunno5(self):
4221         return self.__field_dunno5.getvalue()
4222 
4223     def __setfield_dunno5(self, value):
4224         if isinstance(value,UNKNOWN):
4225             self.__field_dunno5=value
4226         else:
4227             self.__field_dunno5=UNKNOWN(value,**{'sizeinbytes': 17})
4228 
4229     def __delfield_dunno5(self): del self.__field_dunno5
4230 
4231     dunno5=property(__getfield_dunno5, __setfield_dunno5, __delfield_dunno5, None)
4232 
4233     def __getfield_addr_len0(self):
4234         return self.__field_addr_len0.getvalue()
4235 
4236     def __setfield_addr_len0(self, value):
4237         if isinstance(value,UINT):
4238             self.__field_addr_len0=value
4239         else:
4240             self.__field_addr_len0=UINT(value,**{'sizeinbytes': 1})
4241 
4242     def __delfield_addr_len0(self): del self.__field_addr_len0
4243 
4244     addr_len0=property(__getfield_addr_len0, __setfield_addr_len0, __delfield_addr_len0, None)
4245 
4246     def __getfield_addr_len1(self):
4247         return self.__field_addr_len1.getvalue()
4248 
4249     def __setfield_addr_len1(self, value):
4250         if isinstance(value,UINT):
4251             self.__field_addr_len1=value
4252         else:
4253             self.__field_addr_len1=UINT(value,**{'sizeinbytes': 1})
4254 
4255     def __delfield_addr_len1(self): del self.__field_addr_len1
4256 
4257     addr_len1=property(__getfield_addr_len1, __setfield_addr_len1, __delfield_addr_len1, None)
4258 
4259     def __getfield_addr_len2(self):
4260         return self.__field_addr_len2.getvalue()
4261 
4262     def __setfield_addr_len2(self, value):
4263         if isinstance(value,UINT):
4264             self.__field_addr_len2=value
4265         else:
4266             self.__field_addr_len2=UINT(value,**{'sizeinbytes': 1})
4267 
4268     def __delfield_addr_len2(self): del self.__field_addr_len2
4269 
4270     addr_len2=property(__getfield_addr_len2, __setfield_addr_len2, __delfield_addr_len2, None)
4271 
4272     def __getfield_addr_len3(self):
4273         return self.__field_addr_len3.getvalue()
4274 
4275     def __setfield_addr_len3(self, value):
4276         if isinstance(value,UINT):
4277             self.__field_addr_len3=value
4278         else:
4279             self.__field_addr_len3=UINT(value,**{'sizeinbytes': 1})
4280 
4281     def __delfield_addr_len3(self): del self.__field_addr_len3
4282 
4283     addr_len3=property(__getfield_addr_len3, __setfield_addr_len3, __delfield_addr_len3, None)
4284 
4285     def __getfield_addr_len4(self):
4286         return self.__field_addr_len4.getvalue()
4287 
4288     def __setfield_addr_len4(self, value):
4289         if isinstance(value,UINT):
4290             self.__field_addr_len4=value
4291         else:
4292             self.__field_addr_len4=UINT(value,**{'sizeinbytes': 1})
4293 
4294     def __delfield_addr_len4(self): del self.__field_addr_len4
4295 
4296     addr_len4=property(__getfield_addr_len4, __setfield_addr_len4, __delfield_addr_len4, None)
4297 
4298     def __getfield_addr_len5(self):
4299         return self.__field_addr_len5.getvalue()
4300 
4301     def __setfield_addr_len5(self, value):
4302         if isinstance(value,UINT):
4303             self.__field_addr_len5=value
4304         else:
4305             self.__field_addr_len5=UINT(value,**{'sizeinbytes': 1})
4306 
4307     def __delfield_addr_len5(self): del self.__field_addr_len5
4308 
4309     addr_len5=property(__getfield_addr_len5, __setfield_addr_len5, __delfield_addr_len5, None)
4310 
4311     def __getfield_addr_len6(self):
4312         return self.__field_addr_len6.getvalue()
4313 
4314     def __setfield_addr_len6(self, value):
4315         if isinstance(value,UINT):
4316             self.__field_addr_len6=value
4317         else:
4318             self.__field_addr_len6=UINT(value,**{'sizeinbytes': 1})
4319 
4320     def __delfield_addr_len6(self): del self.__field_addr_len6
4321 
4322     addr_len6=property(__getfield_addr_len6, __setfield_addr_len6, __delfield_addr_len6, None)
4323 
4324     def __getfield_addr_len7(self):
4325         return self.__field_addr_len7.getvalue()
4326 
4327     def __setfield_addr_len7(self, value):
4328         if isinstance(value,UINT):
4329             self.__field_addr_len7=value
4330         else:
4331             self.__field_addr_len7=UINT(value,**{'sizeinbytes': 1})
4332 
4333     def __delfield_addr_len7(self): del self.__field_addr_len7
4334 
4335     addr_len7=property(__getfield_addr_len7, __setfield_addr_len7, __delfield_addr_len7, None)
4336 
4337     def __getfield_addr_len8(self):
4338         return self.__field_addr_len8.getvalue()
4339 
4340     def __setfield_addr_len8(self, value):
4341         if isinstance(value,UINT):
4342             self.__field_addr_len8=value
4343         else:
4344             self.__field_addr_len8=UINT(value,**{'sizeinbytes': 1})
4345 
4346     def __delfield_addr_len8(self): del self.__field_addr_len8
4347 
4348     addr_len8=property(__getfield_addr_len8, __setfield_addr_len8, __delfield_addr_len8, None)
4349 
4350     def __getfield_addr_len9(self):
4351         return self.__field_addr_len9.getvalue()
4352 
4353     def __setfield_addr_len9(self, value):
4354         if isinstance(value,UINT):
4355             self.__field_addr_len9=value
4356         else:
4357             self.__field_addr_len9=UINT(value,**{'sizeinbytes': 1})
4358 
4359     def __delfield_addr_len9(self): del self.__field_addr_len9
4360 
4361     addr_len9=property(__getfield_addr_len9, __setfield_addr_len9, __delfield_addr_len9, None)
4362 
4363     def __getfield_addr0(self):
4364         return self.__field_addr0.getvalue()
4365 
4366     def __setfield_addr0(self, value):
4367         if isinstance(value,STRING):
4368             self.__field_addr0=value
4369         else:
4370             self.__field_addr0=STRING(value,**{ 'sizeinbytes': self.addr_len0,                   'terminator': None })
4371 
4372     def __delfield_addr0(self): del self.__field_addr0
4373 
4374     addr0=property(__getfield_addr0, __setfield_addr0, __delfield_addr0, None)
4375 
4376     def __getfield_addr1(self):
4377         return self.__field_addr1.getvalue()
4378 
4379     def __setfield_addr1(self, value):
4380         if isinstance(value,STRING):
4381             self.__field_addr1=value
4382         else:
4383             self.__field_addr1=STRING(value,**{ 'sizeinbytes': self.addr_len1,                   'terminator': None })
4384 
4385     def __delfield_addr1(self): del self.__field_addr1
4386 
4387     addr1=property(__getfield_addr1, __setfield_addr1, __delfield_addr1, None)
4388 
4389     def __getfield_addr2(self):
4390         return self.__field_addr2.getvalue()
4391 
4392     def __setfield_addr2(self, value):
4393         if isinstance(value,STRING):
4394             self.__field_addr2=value
4395         else:
4396             self.__field_addr2=STRING(value,**{ 'sizeinbytes': self.addr_len2,                   'terminator': None })
4397 
4398     def __delfield_addr2(self): del self.__field_addr2
4399 
4400     addr2=property(__getfield_addr2, __setfield_addr2, __delfield_addr2, None)
4401 
4402     def __getfield_addr3(self):
4403         return self.__field_addr3.getvalue()
4404 
4405     def __setfield_addr3(self, value):
4406         if isinstance(value,STRING):
4407             self.__field_addr3=value
4408         else:
4409             self.__field_addr3=STRING(value,**{ 'sizeinbytes': self.addr_len3,                   'terminator': None })
4410 
4411     def __delfield_addr3(self): del self.__field_addr3
4412 
4413     addr3=property(__getfield_addr3, __setfield_addr3, __delfield_addr3, None)
4414 
4415     def __getfield_addr4(self):
4416         return self.__field_addr4.getvalue()
4417 
4418     def __setfield_addr4(self, value):
4419         if isinstance(value,STRING):
4420             self.__field_addr4=value
4421         else:
4422             self.__field_addr4=STRING(value,**{ 'sizeinbytes': self.addr_len4,                   'terminator': None })
4423 
4424     def __delfield_addr4(self): del self.__field_addr4
4425 
4426     addr4=property(__getfield_addr4, __setfield_addr4, __delfield_addr4, None)
4427 
4428     def __getfield_addr5(self):
4429         return self.__field_addr5.getvalue()
4430 
4431     def __setfield_addr5(self, value):
4432         if isinstance(value,STRING):
4433             self.__field_addr5=value
4434         else:
4435             self.__field_addr5=STRING(value,**{ 'sizeinbytes': self.addr_len5,                   'terminator': None })
4436 
4437     def __delfield_addr5(self): del self.__field_addr5
4438 
4439     addr5=property(__getfield_addr5, __setfield_addr5, __delfield_addr5, None)
4440 
4441     def __getfield_addr6(self):
4442         return self.__field_addr6.getvalue()
4443 
4444     def __setfield_addr6(self, value):
4445         if isinstance(value,STRING):
4446             self.__field_addr6=value
4447         else:
4448             self.__field_addr6=STRING(value,**{ 'sizeinbytes': self.addr_len6,                   'terminator': None })
4449 
4450     def __delfield_addr6(self): del self.__field_addr6
4451 
4452     addr6=property(__getfield_addr6, __setfield_addr6, __delfield_addr6, None)
4453 
4454     def __getfield_addr7(self):
4455         return self.__field_addr7.getvalue()
4456 
4457     def __setfield_addr7(self, value):
4458         if isinstance(value,STRING):
4459             self.__field_addr7=value
4460         else:
4461             self.__field_addr7=STRING(value,**{ 'sizeinbytes': self.addr_len7,                   'terminator': None })
4462 
4463     def __delfield_addr7(self): del self.__field_addr7
4464 
4465     addr7=property(__getfield_addr7, __setfield_addr7, __delfield_addr7, None)
4466 
4467     def __getfield_addr8(self):
4468         return self.__field_addr8.getvalue()
4469 
4470     def __setfield_addr8(self, value):
4471         if isinstance(value,STRING):
4472             self.__field_addr8=value
4473         else:
4474             self.__field_addr8=STRING(value,**{ 'sizeinbytes': self.addr_len8,                   'terminator': None })
4475 
4476     def __delfield_addr8(self): del self.__field_addr8
4477 
4478     addr8=property(__getfield_addr8, __setfield_addr8, __delfield_addr8, None)
4479 
4480     def __getfield_addr9(self):
4481         return self.__field_addr9.getvalue()
4482 
4483     def __setfield_addr9(self, value):
4484         if isinstance(value,STRING):
4485             self.__field_addr9=value
4486         else:
4487             self.__field_addr9=STRING(value,**{ 'sizeinbytes': self.addr_len9,                   'terminator': None })
4488 
4489     def __delfield_addr9(self): del self.__field_addr9
4490 
4491     addr9=property(__getfield_addr9, __setfield_addr9, __delfield_addr9, None)
4492 
4493     def __getfield_dunno6(self):
4494         return self.__field_dunno6.getvalue()
4495 
4496     def __setfield_dunno6(self, value):
4497         if isinstance(value,UNKNOWN):
4498             self.__field_dunno6=value
4499         else:
4500             self.__field_dunno6=UNKNOWN(value,**{'sizeinbytes': 1})
4501 
4502     def __delfield_dunno6(self): del self.__field_dunno6
4503 
4504     dunno6=property(__getfield_dunno6, __setfield_dunno6, __delfield_dunno6, None)
4505 
4506     def __getfield_dunno7(self):
4507         return self.__field_dunno7.getvalue()
4508 
4509     def __setfield_dunno7(self, value):
4510         if isinstance(value,UNKNOWN):
4511             self.__field_dunno7=value
4512         else:
4513             self.__field_dunno7=UNKNOWN(value,**{'sizeinbytes': 1})
4514 
4515     def __delfield_dunno7(self): del self.__field_dunno7
4516 
4517     dunno7=property(__getfield_dunno7, __setfield_dunno7, __delfield_dunno7, None)
4518 
4519     def __getfield_dunno8(self):
4520         return self.__field_dunno8.getvalue()
4521 
4522     def __setfield_dunno8(self, value):
4523         if isinstance(value,UNKNOWN):
4524             self.__field_dunno8=value
4525         else:
4526             self.__field_dunno8=UNKNOWN(value,**{'sizeinbytes': 81})
4527 
4528     def __delfield_dunno8(self): del self.__field_dunno8
4529 
4530     dunno8=property(__getfield_dunno8, __setfield_dunno8, __delfield_dunno8, None)
4531 
4532     def __getfield_dunno9(self):
4533         return self.__field_dunno9.getvalue()
4534 
4535     def __setfield_dunno9(self, value):
4536         if isinstance(value,UNKNOWN):
4537             self.__field_dunno9=value
4538         else:
4539             self.__field_dunno9=UNKNOWN(value,**{'sizeinbytes': 40})
4540 
4541     def __delfield_dunno9(self): del self.__field_dunno9
4542 
4543     dunno9=property(__getfield_dunno9, __setfield_dunno9, __delfield_dunno9, None)
4544 
4545     def __getfield_msg_stat(self):
4546         return self.__field_msg_stat.getvalue()
4547 
4548     def __setfield_msg_stat(self, value):
4549         if isinstance(value,LIST):
4550             self.__field_msg_stat=value
4551         else:
4552             self.__field_msg_stat=LIST(value,**{ 'elementclass': sms_msg_stat_list,             'length': 10 })
4553 
4554     def __delfield_msg_stat(self): del self.__field_msg_stat
4555 
4556     msg_stat=property(__getfield_msg_stat, __setfield_msg_stat, __delfield_msg_stat, None)
4557 
4558     def iscontainer(self):
4559         return True
4560 
4561     def containerelements(self):
4562         yield ('msg_len', self.__field_msg_len, None)
4563         yield ('has_callback', self.__field_has_callback, None)
4564         yield ('has_priority', self.__field_has_priority, None)
4565         yield ('has_1byte', self.__field_has_1byte, None)
4566         yield ('has_1byte2', self.__field_has_1byte2, None)
4567         yield ('has_40bytes', self.__field_has_40bytes, None)
4568         yield ('dunno1', self.__field_dunno1, None)
4569         yield ('msg', self.__field_msg, None)
4570         if self.has_callback:
4571             yield ('dunno2', self.__field_dunno2, None)
4572             yield ('callback_len', self.__field_callback_len, None)
4573             yield ('callback', self.__field_callback, None)
4574         if self.has_priority:
4575             yield ('priority', self.__field_priority, None)
4576         if self.has_1byte:
4577             yield ('dunno3', self.__field_dunno3, None)
4578         yield ('dunno4', self.__field_dunno4, None)
4579         yield ('datetime', self.__field_datetime, None)
4580         yield ('dunno5', self.__field_dunno5, None)
4581         yield ('addr_len0', self.__field_addr_len0, None)
4582         yield ('addr_len1', self.__field_addr_len1, None)
4583         yield ('addr_len2', self.__field_addr_len2, None)
4584         yield ('addr_len3', self.__field_addr_len3, None)
4585         yield ('addr_len4', self.__field_addr_len4, None)
4586         yield ('addr_len5', self.__field_addr_len5, None)
4587         yield ('addr_len6', self.__field_addr_len6, None)
4588         yield ('addr_len7', self.__field_addr_len7, None)
4589         yield ('addr_len8', self.__field_addr_len8, None)
4590         yield ('addr_len9', self.__field_addr_len9, None)
4591         if self.addr_len0:
4592             yield ('addr0', self.__field_addr0, None)
4593         if self.addr_len1:
4594             yield ('addr1', self.__field_addr1, None)
4595         if self.addr_len2:
4596             yield ('addr2', self.__field_addr2, None)
4597         if self.addr_len3:
4598             yield ('addr3', self.__field_addr3, None)
4599         if self.addr_len4:
4600             yield ('addr4', self.__field_addr4, None)
4601         if self.addr_len5:
4602             yield ('addr5', self.__field_addr5, None)
4603         if self.addr_len6:
4604             yield ('addr6', self.__field_addr6, None)
4605         if self.addr_len7:
4606             yield ('addr7', self.__field_addr7, None)
4607         if self.addr_len8:
4608             yield ('addr8', self.__field_addr8, None)
4609         if self.addr_len9:
4610             yield ('addr9', self.__field_addr9, None)
4611         if not self.has_1byte and self.has_1byte2:
4612             yield ('dunno6', self.__field_dunno6, None)
4613         if self.has_1byte2:
4614             yield ('dunno7', self.__field_dunno7, None)
4615         yield ('dunno8', self.__field_dunno8, None)
4616         if self.has_40bytes:
4617             yield ('dunno9', self.__field_dunno9, None)
4618         yield ('msg_stat', self.__field_msg_stat, None)
4619 
4620 
4621 
4622 
4623