PyXR

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