PyXR

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

0001 # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE
0002 
0003 """Various descriptions of data specific to LG VX8000"""
0004 
0005 from prototypes import *
0006 from prototypeslg import *
0007 
0008 # Make all lg stuff available in this module as well
0009 from p_lg import *
0010 
0011 # we are the same as lgvx7000 except as noted
0012 # below
0013 from p_lgvx7000 import *
0014 
0015 # We use LSB for all integer like fields
0016 UINT=UINTlsb
0017 BOOL=BOOLlsb
0018 
0019 # vx8100 uses a type based index for speed dials instead of positional like the vx4400
0020 SPEEDDIALINDEX=1 
0021 MAXCALENDARDESCRIPTION=32
0022 MAX_PHONEBOOK_GROUPS=30
0023 CALENDAR_HAS_SEPARATE_END_TIME_AND_DATE=0
0024 
0025 
0026 SMS_CANNED_MAX_ITEMS=18
0027 SMS_CANNED_MAX_LENGTH=101
0028 
0029 BREW_FILE_SYSTEM=2
0030 
0031 # Media type
0032 MEDIA_TYPE_RINGTONE=0x0201
0033 MEDIA_TYPE_IMAGE=0x0100
0034 MEDIA_TYPE_SOUND=0x0402
0035 MEDIA_TYPE_SDIMAGE=0x0008
0036 MEDIA_TYPE_SDSOUND=0x000C
0037 MEDIA_TYPE_VIDEO=0x0304
0038 MEDIA_RINGTONE_DEFAULT_ICON=1
0039 MEDIA_IMAGE_DEFAULT_ICON=0
0040 MEDIA_VIDEO_DEFAULT_ICON=0
0041 
0042 PHONE_ENCODING='iso8859_1'
0043 
0044 # need to call stat to get the file time/data
0045 broken_filelist_date=True
0046 
0047 class indexentry(BaseProtogenClass):
0048     __fields=['index', 'type', 'filename', 'icon', 'date', 'dunno', 'size']
0049 
0050     def __init__(self, *args, **kwargs):
0051         dict={}
0052         # What was supplied to this function
0053         dict.update(kwargs)
0054         # Parent constructor
0055         super(indexentry,self).__init__(**dict)
0056         if self.__class__ is indexentry:
0057             self._update(args,dict)
0058 
0059 
0060     def getfields(self):
0061         return self.__fields
0062 
0063 
0064     def _update(self, args, kwargs):
0065         super(indexentry,self)._update(args,kwargs)
0066         keys=kwargs.keys()
0067         for key in keys:
0068             if key in self.__fields:
0069                 setattr(self, key, kwargs[key])
0070                 del kwargs[key]
0071         # Were any unrecognized kwargs passed in?
0072         if __debug__:
0073             self._complainaboutunusedargs(indexentry,kwargs)
0074         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0075         # Make all P fields that haven't already been constructed
0076 
0077 
0078     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0079         'Writes this packet to the supplied buffer'
0080         self._bufferstartoffset=buf.getcurrentoffset()
0081         self.__field_index.writetobuffer(buf)
0082         self.__field_type.writetobuffer(buf)
0083         self.__field_filename.writetobuffer(buf)
0084         try: self.__field_icon
0085         except:
0086             self.__field_icon=UINT(**{'sizeinbytes': 4, 'default':0})
0087         self.__field_icon.writetobuffer(buf)
0088         try: self.__field_date
0089         except:
0090             self.__field_date=UINT(**{'sizeinbytes': 4, 'default': 0})
0091         self.__field_date.writetobuffer(buf)
0092         self.__field_dunno.writetobuffer(buf)
0093         try: self.__field_size
0094         except:
0095             self.__field_size=UINT(**{'sizeinbytes': 4, 'default': 0})
0096         self.__field_size.writetobuffer(buf)
0097         self._bufferendoffset=buf.getcurrentoffset()
0098         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0099 
0100 
0101     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0102         'Reads this packet from the supplied buffer'
0103         self._bufferstartoffset=buf.getcurrentoffset()
0104         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0105         self.__field_index=UINT(**{'sizeinbytes': 2})
0106         self.__field_index.readfrombuffer(buf)
0107         self.__field_type=UINT(**{'sizeinbytes': 2})
0108         self.__field_type.readfrombuffer(buf)
0109         self.__field_filename=USTRING(**{'sizeinbytes': 60, 'raiseonunterminatedread': False, 'raiseontruncate': False })
0110         self.__field_filename.readfrombuffer(buf)
0111         self.__field_icon=UINT(**{'sizeinbytes': 4, 'default':0})
0112         self.__field_icon.readfrombuffer(buf)
0113         self.__field_date=UINT(**{'sizeinbytes': 4, 'default': 0})
0114         self.__field_date.readfrombuffer(buf)
0115         self.__field_dunno=UINT(**{'sizeinbytes': 4})
0116         self.__field_dunno.readfrombuffer(buf)
0117         self.__field_size=UINT(**{'sizeinbytes': 4, 'default': 0})
0118         self.__field_size.readfrombuffer(buf)
0119         self._bufferendoffset=buf.getcurrentoffset()
0120 
0121 
0122     def __getfield_index(self):
0123         return self.__field_index.getvalue()
0124 
0125     def __setfield_index(self, value):
0126         if isinstance(value,UINT):
0127             self.__field_index=value
0128         else:
0129             self.__field_index=UINT(value,**{'sizeinbytes': 2})
0130 
0131     def __delfield_index(self): del self.__field_index
0132 
0133     index=property(__getfield_index, __setfield_index, __delfield_index, None)
0134 
0135     def __getfield_type(self):
0136         return self.__field_type.getvalue()
0137 
0138     def __setfield_type(self, value):
0139         if isinstance(value,UINT):
0140             self.__field_type=value
0141         else:
0142             self.__field_type=UINT(value,**{'sizeinbytes': 2})
0143 
0144     def __delfield_type(self): del self.__field_type
0145 
0146     type=property(__getfield_type, __setfield_type, __delfield_type, None)
0147 
0148     def __getfield_filename(self):
0149         return self.__field_filename.getvalue()
0150 
0151     def __setfield_filename(self, value):
0152         if isinstance(value,USTRING):
0153             self.__field_filename=value
0154         else:
0155             self.__field_filename=USTRING(value,**{'sizeinbytes': 60, 'raiseonunterminatedread': False, 'raiseontruncate': False })
0156 
0157     def __delfield_filename(self): del self.__field_filename
0158 
0159     filename=property(__getfield_filename, __setfield_filename, __delfield_filename, "includes full pathname")
0160 
0161     def __getfield_icon(self):
0162         try: self.__field_icon
0163         except:
0164             self.__field_icon=UINT(**{'sizeinbytes': 4, 'default':0})
0165         return self.__field_icon.getvalue()
0166 
0167     def __setfield_icon(self, value):
0168         if isinstance(value,UINT):
0169             self.__field_icon=value
0170         else:
0171             self.__field_icon=UINT(value,**{'sizeinbytes': 4, 'default':0})
0172 
0173     def __delfield_icon(self): del self.__field_icon
0174 
0175     icon=property(__getfield_icon, __setfield_icon, __delfield_icon, None)
0176 
0177     def __getfield_date(self):
0178         try: self.__field_date
0179         except:
0180             self.__field_date=UINT(**{'sizeinbytes': 4, 'default': 0})
0181         return self.__field_date.getvalue()
0182 
0183     def __setfield_date(self, value):
0184         if isinstance(value,UINT):
0185             self.__field_date=value
0186         else:
0187             self.__field_date=UINT(value,**{'sizeinbytes': 4, 'default': 0})
0188 
0189     def __delfield_date(self): del self.__field_date
0190 
0191     date=property(__getfield_date, __setfield_date, __delfield_date, "i think this is bitfield of the date")
0192 
0193     def __getfield_dunno(self):
0194         return self.__field_dunno.getvalue()
0195 
0196     def __setfield_dunno(self, value):
0197         if isinstance(value,UINT):
0198             self.__field_dunno=value
0199         else:
0200             self.__field_dunno=UINT(value,**{'sizeinbytes': 4})
0201 
0202     def __delfield_dunno(self): del self.__field_dunno
0203 
0204     dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, None)
0205 
0206     def __getfield_size(self):
0207         try: self.__field_size
0208         except:
0209             self.__field_size=UINT(**{'sizeinbytes': 4, 'default': 0})
0210         return self.__field_size.getvalue()
0211 
0212     def __setfield_size(self, value):
0213         if isinstance(value,UINT):
0214             self.__field_size=value
0215         else:
0216             self.__field_size=UINT(value,**{'sizeinbytes': 4, 'default': 0})
0217 
0218     def __delfield_size(self): del self.__field_size
0219 
0220     size=property(__getfield_size, __setfield_size, __delfield_size, "size of the file, can be set to zero")
0221 
0222     def iscontainer(self):
0223         return True
0224 
0225     def containerelements(self):
0226         yield ('index', self.__field_index, None)
0227         yield ('type', self.__field_type, None)
0228         yield ('filename', self.__field_filename, "includes full pathname")
0229         yield ('icon', self.__field_icon, None)
0230         yield ('date', self.__field_date, "i think this is bitfield of the date")
0231         yield ('dunno', self.__field_dunno, None)
0232         yield ('size', self.__field_size, "size of the file, can be set to zero")
0233 
0234 
0235 
0236 
0237 class indexfile(BaseProtogenClass):
0238     "Used for tracking wallpaper and ringtones"
0239     __fields=['items']
0240 
0241     def __init__(self, *args, **kwargs):
0242         dict={}
0243         # What was supplied to this function
0244         dict.update(kwargs)
0245         # Parent constructor
0246         super(indexfile,self).__init__(**dict)
0247         if self.__class__ is indexfile:
0248             self._update(args,dict)
0249 
0250 
0251     def getfields(self):
0252         return self.__fields
0253 
0254 
0255     def _update(self, args, kwargs):
0256         super(indexfile,self)._update(args,kwargs)
0257         keys=kwargs.keys()
0258         for key in keys:
0259             if key in self.__fields:
0260                 setattr(self, key, kwargs[key])
0261                 del kwargs[key]
0262         # Were any unrecognized kwargs passed in?
0263         if __debug__:
0264             self._complainaboutunusedargs(indexfile,kwargs)
0265         if len(args):
0266             dict2={'elementclass': indexentry, 'createdefault': True}
0267             dict2.update(kwargs)
0268             kwargs=dict2
0269             self.__field_items=LIST(*args,**dict2)
0270         # Make all P fields that haven't already been constructed
0271 
0272 
0273     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0274         'Writes this packet to the supplied buffer'
0275         self._bufferstartoffset=buf.getcurrentoffset()
0276         try: self.__field_items
0277         except:
0278             self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True})
0279         self.__field_items.writetobuffer(buf)
0280         self._bufferendoffset=buf.getcurrentoffset()
0281         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0282 
0283 
0284     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0285         'Reads this packet from the supplied buffer'
0286         self._bufferstartoffset=buf.getcurrentoffset()
0287         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0288         self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True})
0289         self.__field_items.readfrombuffer(buf)
0290         self._bufferendoffset=buf.getcurrentoffset()
0291 
0292 
0293     def __getfield_items(self):
0294         try: self.__field_items
0295         except:
0296             self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True})
0297         return self.__field_items.getvalue()
0298 
0299     def __setfield_items(self, value):
0300         if isinstance(value,LIST):
0301             self.__field_items=value
0302         else:
0303             self.__field_items=LIST(value,**{'elementclass': indexentry, 'createdefault': True})
0304 
0305     def __delfield_items(self): del self.__field_items
0306 
0307     items=property(__getfield_items, __setfield_items, __delfield_items, None)
0308 
0309     def iscontainer(self):
0310         return True
0311 
0312     def containerelements(self):
0313         yield ('items', self.__field_items, None)
0314 
0315 
0316 
0317 
0318 class pbgroup(BaseProtogenClass):
0319     "A single group"
0320     __fields=['name']
0321 
0322     def __init__(self, *args, **kwargs):
0323         dict={}
0324         # What was supplied to this function
0325         dict.update(kwargs)
0326         # Parent constructor
0327         super(pbgroup,self).__init__(**dict)
0328         if self.__class__ is pbgroup:
0329             self._update(args,dict)
0330 
0331 
0332     def getfields(self):
0333         return self.__fields
0334 
0335 
0336     def _update(self, args, kwargs):
0337         super(pbgroup,self)._update(args,kwargs)
0338         keys=kwargs.keys()
0339         for key in keys:
0340             if key in self.__fields:
0341                 setattr(self, key, kwargs[key])
0342                 del kwargs[key]
0343         # Were any unrecognized kwargs passed in?
0344         if __debug__:
0345             self._complainaboutunusedargs(pbgroup,kwargs)
0346         if len(args):
0347             dict2={'sizeinbytes': 23, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False }
0348             dict2.update(kwargs)
0349             kwargs=dict2
0350             self.__field_name=USTRING(*args,**dict2)
0351         # Make all P fields that haven't already been constructed
0352 
0353 
0354     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0355         'Writes this packet to the supplied buffer'
0356         self._bufferstartoffset=buf.getcurrentoffset()
0357         self.__field_name.writetobuffer(buf)
0358         self._bufferendoffset=buf.getcurrentoffset()
0359         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0360 
0361 
0362     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0363         'Reads this packet from the supplied buffer'
0364         self._bufferstartoffset=buf.getcurrentoffset()
0365         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0366         self.__field_name=USTRING(**{'sizeinbytes': 23, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False })
0367         self.__field_name.readfrombuffer(buf)
0368         self._bufferendoffset=buf.getcurrentoffset()
0369 
0370 
0371     def __getfield_name(self):
0372         return self.__field_name.getvalue()
0373 
0374     def __setfield_name(self, value):
0375         if isinstance(value,USTRING):
0376             self.__field_name=value
0377         else:
0378             self.__field_name=USTRING(value,**{'sizeinbytes': 23, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False })
0379 
0380     def __delfield_name(self): del self.__field_name
0381 
0382     name=property(__getfield_name, __setfield_name, __delfield_name, None)
0383 
0384     def iscontainer(self):
0385         return True
0386 
0387     def containerelements(self):
0388         yield ('name', self.__field_name, None)
0389 
0390 
0391 
0392 
0393 class pbgroups(BaseProtogenClass):
0394     "Phonebook groups"
0395     __fields=['groups']
0396 
0397     def __init__(self, *args, **kwargs):
0398         dict={}
0399         # What was supplied to this function
0400         dict.update(kwargs)
0401         # Parent constructor
0402         super(pbgroups,self).__init__(**dict)
0403         if self.__class__ is pbgroups:
0404             self._update(args,dict)
0405 
0406 
0407     def getfields(self):
0408         return self.__fields
0409 
0410 
0411     def _update(self, args, kwargs):
0412         super(pbgroups,self)._update(args,kwargs)
0413         keys=kwargs.keys()
0414         for key in keys:
0415             if key in self.__fields:
0416                 setattr(self, key, kwargs[key])
0417                 del kwargs[key]
0418         # Were any unrecognized kwargs passed in?
0419         if __debug__:
0420             self._complainaboutunusedargs(pbgroups,kwargs)
0421         if len(args):
0422             dict2={'elementclass': pbgroup}
0423             dict2.update(kwargs)
0424             kwargs=dict2
0425             self.__field_groups=LIST(*args,**dict2)
0426         # Make all P fields that haven't already been constructed
0427 
0428 
0429     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0430         'Writes this packet to the supplied buffer'
0431         self._bufferstartoffset=buf.getcurrentoffset()
0432         try: self.__field_groups
0433         except:
0434             self.__field_groups=LIST(**{'elementclass': pbgroup})
0435         self.__field_groups.writetobuffer(buf)
0436         self._bufferendoffset=buf.getcurrentoffset()
0437         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0438 
0439 
0440     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0441         'Reads this packet from the supplied buffer'
0442         self._bufferstartoffset=buf.getcurrentoffset()
0443         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0444         self.__field_groups=LIST(**{'elementclass': pbgroup})
0445         self.__field_groups.readfrombuffer(buf)
0446         self._bufferendoffset=buf.getcurrentoffset()
0447 
0448 
0449     def __getfield_groups(self):
0450         try: self.__field_groups
0451         except:
0452             self.__field_groups=LIST(**{'elementclass': pbgroup})
0453         return self.__field_groups.getvalue()
0454 
0455     def __setfield_groups(self, value):
0456         if isinstance(value,LIST):
0457             self.__field_groups=value
0458         else:
0459             self.__field_groups=LIST(value,**{'elementclass': pbgroup})
0460 
0461     def __delfield_groups(self): del self.__field_groups
0462 
0463     groups=property(__getfield_groups, __setfield_groups, __delfield_groups, None)
0464 
0465     def iscontainer(self):
0466         return True
0467 
0468     def containerelements(self):
0469         yield ('groups', self.__field_groups, None)
0470 
0471 
0472 
0473 
0474 class scheduleexception(BaseProtogenClass):
0475     __fields=['pos', 'day', 'month', 'year']
0476 
0477     def __init__(self, *args, **kwargs):
0478         dict={}
0479         # What was supplied to this function
0480         dict.update(kwargs)
0481         # Parent constructor
0482         super(scheduleexception,self).__init__(**dict)
0483         if self.__class__ is scheduleexception:
0484             self._update(args,dict)
0485 
0486 
0487     def getfields(self):
0488         return self.__fields
0489 
0490 
0491     def _update(self, args, kwargs):
0492         super(scheduleexception,self)._update(args,kwargs)
0493         keys=kwargs.keys()
0494         for key in keys:
0495             if key in self.__fields:
0496                 setattr(self, key, kwargs[key])
0497                 del kwargs[key]
0498         # Were any unrecognized kwargs passed in?
0499         if __debug__:
0500             self._complainaboutunusedargs(scheduleexception,kwargs)
0501         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0502         # Make all P fields that haven't already been constructed
0503 
0504 
0505     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0506         'Writes this packet to the supplied buffer'
0507         self._bufferstartoffset=buf.getcurrentoffset()
0508         self.__field_pos.writetobuffer(buf)
0509         self.__field_day.writetobuffer(buf)
0510         self.__field_month.writetobuffer(buf)
0511         self.__field_year.writetobuffer(buf)
0512         self._bufferendoffset=buf.getcurrentoffset()
0513         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0514 
0515 
0516     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0517         'Reads this packet from the supplied buffer'
0518         self._bufferstartoffset=buf.getcurrentoffset()
0519         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0520         self.__field_pos=UINT(**{'sizeinbytes': 4})
0521         self.__field_pos.readfrombuffer(buf)
0522         self.__field_day=UINT(**{'sizeinbytes': 1})
0523         self.__field_day.readfrombuffer(buf)
0524         self.__field_month=UINT(**{'sizeinbytes': 1})
0525         self.__field_month.readfrombuffer(buf)
0526         self.__field_year=UINT(**{'sizeinbytes': 2})
0527         self.__field_year.readfrombuffer(buf)
0528         self._bufferendoffset=buf.getcurrentoffset()
0529 
0530 
0531     def __getfield_pos(self):
0532         return self.__field_pos.getvalue()
0533 
0534     def __setfield_pos(self, value):
0535         if isinstance(value,UINT):
0536             self.__field_pos=value
0537         else:
0538             self.__field_pos=UINT(value,**{'sizeinbytes': 4})
0539 
0540     def __delfield_pos(self): del self.__field_pos
0541 
0542     pos=property(__getfield_pos, __setfield_pos, __delfield_pos, "Refers to event id (position in schedule file) that this suppresses")
0543 
0544     def __getfield_day(self):
0545         return self.__field_day.getvalue()
0546 
0547     def __setfield_day(self, value):
0548         if isinstance(value,UINT):
0549             self.__field_day=value
0550         else:
0551             self.__field_day=UINT(value,**{'sizeinbytes': 1})
0552 
0553     def __delfield_day(self): del self.__field_day
0554 
0555     day=property(__getfield_day, __setfield_day, __delfield_day, None)
0556 
0557     def __getfield_month(self):
0558         return self.__field_month.getvalue()
0559 
0560     def __setfield_month(self, value):
0561         if isinstance(value,UINT):
0562             self.__field_month=value
0563         else:
0564             self.__field_month=UINT(value,**{'sizeinbytes': 1})
0565 
0566     def __delfield_month(self): del self.__field_month
0567 
0568     month=property(__getfield_month, __setfield_month, __delfield_month, None)
0569 
0570     def __getfield_year(self):
0571         return self.__field_year.getvalue()
0572 
0573     def __setfield_year(self, value):
0574         if isinstance(value,UINT):
0575             self.__field_year=value
0576         else:
0577             self.__field_year=UINT(value,**{'sizeinbytes': 2})
0578 
0579     def __delfield_year(self): del self.__field_year
0580 
0581     year=property(__getfield_year, __setfield_year, __delfield_year, None)
0582 
0583     def iscontainer(self):
0584         return True
0585 
0586     def containerelements(self):
0587         yield ('pos', self.__field_pos, "Refers to event id (position in schedule file) that this suppresses")
0588         yield ('day', self.__field_day, None)
0589         yield ('month', self.__field_month, None)
0590         yield ('year', self.__field_year, None)
0591 
0592 
0593 
0594 
0595 class scheduleexceptionfile(BaseProtogenClass):
0596     __fields=['items']
0597 
0598     def __init__(self, *args, **kwargs):
0599         dict={}
0600         # What was supplied to this function
0601         dict.update(kwargs)
0602         # Parent constructor
0603         super(scheduleexceptionfile,self).__init__(**dict)
0604         if self.__class__ is scheduleexceptionfile:
0605             self._update(args,dict)
0606 
0607 
0608     def getfields(self):
0609         return self.__fields
0610 
0611 
0612     def _update(self, args, kwargs):
0613         super(scheduleexceptionfile,self)._update(args,kwargs)
0614         keys=kwargs.keys()
0615         for key in keys:
0616             if key in self.__fields:
0617                 setattr(self, key, kwargs[key])
0618                 del kwargs[key]
0619         # Were any unrecognized kwargs passed in?
0620         if __debug__:
0621             self._complainaboutunusedargs(scheduleexceptionfile,kwargs)
0622         if len(args):
0623             dict2={'elementclass': scheduleexception}
0624             dict2.update(kwargs)
0625             kwargs=dict2
0626             self.__field_items=LIST(*args,**dict2)
0627         # Make all P fields that haven't already been constructed
0628 
0629 
0630     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0631         'Writes this packet to the supplied buffer'
0632         self._bufferstartoffset=buf.getcurrentoffset()
0633         try: self.__field_items
0634         except:
0635             self.__field_items=LIST(**{'elementclass': scheduleexception})
0636         self.__field_items.writetobuffer(buf)
0637         self._bufferendoffset=buf.getcurrentoffset()
0638         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0639 
0640 
0641     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0642         'Reads this packet from the supplied buffer'
0643         self._bufferstartoffset=buf.getcurrentoffset()
0644         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0645         self.__field_items=LIST(**{'elementclass': scheduleexception})
0646         self.__field_items.readfrombuffer(buf)
0647         self._bufferendoffset=buf.getcurrentoffset()
0648 
0649 
0650     def __getfield_items(self):
0651         try: self.__field_items
0652         except:
0653             self.__field_items=LIST(**{'elementclass': scheduleexception})
0654         return self.__field_items.getvalue()
0655 
0656     def __setfield_items(self, value):
0657         if isinstance(value,LIST):
0658             self.__field_items=value
0659         else:
0660             self.__field_items=LIST(value,**{'elementclass': scheduleexception})
0661 
0662     def __delfield_items(self): del self.__field_items
0663 
0664     items=property(__getfield_items, __setfield_items, __delfield_items, None)
0665 
0666     def iscontainer(self):
0667         return True
0668 
0669     def containerelements(self):
0670         yield ('items', self.__field_items, None)
0671 
0672 
0673 
0674 
0675 class scheduleevent(BaseProtogenClass):
0676     __fields=['pos', 'description', 'start', 'end', 'repeat', 'alarmindex_vibrate', 'ringtone', 'unknown1', 'alarmminutes', 'alarmhours', 'unknown2']
0677 
0678     def __init__(self, *args, **kwargs):
0679         dict={}
0680         # What was supplied to this function
0681         dict.update(kwargs)
0682         # Parent constructor
0683         super(scheduleevent,self).__init__(**dict)
0684         if self.__class__ is scheduleevent:
0685             self._update(args,dict)
0686 
0687 
0688     def getfields(self):
0689         return self.__fields
0690 
0691 
0692     def _update(self, args, kwargs):
0693         super(scheduleevent,self)._update(args,kwargs)
0694         keys=kwargs.keys()
0695         for key in keys:
0696             if key in self.__fields:
0697                 setattr(self, key, kwargs[key])
0698                 del kwargs[key]
0699         # Were any unrecognized kwargs passed in?
0700         if __debug__:
0701             self._complainaboutunusedargs(scheduleevent,kwargs)
0702         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0703         # Make all P fields that haven't already been constructed
0704 
0705 
0706     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0707         'Writes this packet to the supplied buffer'
0708         self._bufferstartoffset=buf.getcurrentoffset()
0709         self.__field_pos.writetobuffer(buf)
0710         self.__field_description.writetobuffer(buf)
0711         self.__field_start.writetobuffer(buf)
0712         self.__field_end.writetobuffer(buf)
0713         self.__field_repeat.writetobuffer(buf)
0714         self.__field_alarmindex_vibrate.writetobuffer(buf)
0715         self.__field_ringtone.writetobuffer(buf)
0716         self.__field_unknown1.writetobuffer(buf)
0717         self.__field_alarmminutes.writetobuffer(buf)
0718         self.__field_alarmhours.writetobuffer(buf)
0719         self.__field_unknown2.writetobuffer(buf)
0720         self._bufferendoffset=buf.getcurrentoffset()
0721         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0722 
0723 
0724     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0725         'Reads this packet from the supplied buffer'
0726         self._bufferstartoffset=buf.getcurrentoffset()
0727         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0728         self.__field_pos=UINT(**{'sizeinbytes': 4})
0729         self.__field_pos.readfrombuffer(buf)
0730         self.__field_description=USTRING(**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False })
0731         self.__field_description.readfrombuffer(buf)
0732         self.__field_start=LGCALDATE(**{'sizeinbytes': 4})
0733         self.__field_start.readfrombuffer(buf)
0734         self.__field_end=LGCALDATE(**{'sizeinbytes': 4})
0735         self.__field_end.readfrombuffer(buf)
0736         self.__field_repeat=LGCALREPEAT(**{'sizeinbytes': 4})
0737         self.__field_repeat.readfrombuffer(buf)
0738         self.__field_alarmindex_vibrate=UINT(**{'sizeinbytes': 1})
0739         self.__field_alarmindex_vibrate.readfrombuffer(buf)
0740         self.__field_ringtone=UINT(**{'sizeinbytes': 1})
0741         self.__field_ringtone.readfrombuffer(buf)
0742         self.__field_unknown1=UINT(**{'sizeinbytes': 1})
0743         self.__field_unknown1.readfrombuffer(buf)
0744         self.__field_alarmminutes=UINT(**{'sizeinbytes': 1})
0745         self.__field_alarmminutes.readfrombuffer(buf)
0746         self.__field_alarmhours=UINT(**{'sizeinbytes': 1})
0747         self.__field_alarmhours.readfrombuffer(buf)
0748         self.__field_unknown2=UINT(**{'sizeinbytes': 1})
0749         self.__field_unknown2.readfrombuffer(buf)
0750         self._bufferendoffset=buf.getcurrentoffset()
0751 
0752 
0753     def __getfield_pos(self):
0754         return self.__field_pos.getvalue()
0755 
0756     def __setfield_pos(self, value):
0757         if isinstance(value,UINT):
0758             self.__field_pos=value
0759         else:
0760             self.__field_pos=UINT(value,**{'sizeinbytes': 4})
0761 
0762     def __delfield_pos(self): del self.__field_pos
0763 
0764     pos=property(__getfield_pos, __setfield_pos, __delfield_pos, "position within file, used as an event id")
0765 
0766     def __getfield_description(self):
0767         return self.__field_description.getvalue()
0768 
0769     def __setfield_description(self, value):
0770         if isinstance(value,USTRING):
0771             self.__field_description=value
0772         else:
0773             self.__field_description=USTRING(value,**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False })
0774 
0775     def __delfield_description(self): del self.__field_description
0776 
0777     description=property(__getfield_description, __setfield_description, __delfield_description, None)
0778 
0779     def __getfield_start(self):
0780         return self.__field_start.getvalue()
0781 
0782     def __setfield_start(self, value):
0783         if isinstance(value,LGCALDATE):
0784             self.__field_start=value
0785         else:
0786             self.__field_start=LGCALDATE(value,**{'sizeinbytes': 4})
0787 
0788     def __delfield_start(self): del self.__field_start
0789 
0790     start=property(__getfield_start, __setfield_start, __delfield_start, None)
0791 
0792     def __getfield_end(self):
0793         return self.__field_end.getvalue()
0794 
0795     def __setfield_end(self, value):
0796         if isinstance(value,LGCALDATE):
0797             self.__field_end=value
0798         else:
0799             self.__field_end=LGCALDATE(value,**{'sizeinbytes': 4})
0800 
0801     def __delfield_end(self): del self.__field_end
0802 
0803     end=property(__getfield_end, __setfield_end, __delfield_end, None)
0804 
0805     def __getfield_repeat(self):
0806         return self.__field_repeat.getvalue()
0807 
0808     def __setfield_repeat(self, value):
0809         if isinstance(value,LGCALREPEAT):
0810             self.__field_repeat=value
0811         else:
0812             self.__field_repeat=LGCALREPEAT(value,**{'sizeinbytes': 4})
0813 
0814     def __delfield_repeat(self): del self.__field_repeat
0815 
0816     repeat=property(__getfield_repeat, __setfield_repeat, __delfield_repeat, None)
0817 
0818     def __getfield_alarmindex_vibrate(self):
0819         return self.__field_alarmindex_vibrate.getvalue()
0820 
0821     def __setfield_alarmindex_vibrate(self, value):
0822         if isinstance(value,UINT):
0823             self.__field_alarmindex_vibrate=value
0824         else:
0825             self.__field_alarmindex_vibrate=UINT(value,**{'sizeinbytes': 1})
0826 
0827     def __delfield_alarmindex_vibrate(self): del self.__field_alarmindex_vibrate
0828 
0829     alarmindex_vibrate=property(__getfield_alarmindex_vibrate, __setfield_alarmindex_vibrate, __delfield_alarmindex_vibrate, None)
0830 
0831     def __getfield_ringtone(self):
0832         return self.__field_ringtone.getvalue()
0833 
0834     def __setfield_ringtone(self, value):
0835         if isinstance(value,UINT):
0836             self.__field_ringtone=value
0837         else:
0838             self.__field_ringtone=UINT(value,**{'sizeinbytes': 1})
0839 
0840     def __delfield_ringtone(self): del self.__field_ringtone
0841 
0842     ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None)
0843 
0844     def __getfield_unknown1(self):
0845         return self.__field_unknown1.getvalue()
0846 
0847     def __setfield_unknown1(self, value):
0848         if isinstance(value,UINT):
0849             self.__field_unknown1=value
0850         else:
0851             self.__field_unknown1=UINT(value,**{'sizeinbytes': 1})
0852 
0853     def __delfield_unknown1(self): del self.__field_unknown1
0854 
0855     unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None)
0856 
0857     def __getfield_alarmminutes(self):
0858         return self.__field_alarmminutes.getvalue()
0859 
0860     def __setfield_alarmminutes(self, value):
0861         if isinstance(value,UINT):
0862             self.__field_alarmminutes=value
0863         else:
0864             self.__field_alarmminutes=UINT(value,**{'sizeinbytes': 1})
0865 
0866     def __delfield_alarmminutes(self): del self.__field_alarmminutes
0867 
0868     alarmminutes=property(__getfield_alarmminutes, __setfield_alarmminutes, __delfield_alarmminutes, "a value of 0xFF indicates not set")
0869 
0870     def __getfield_alarmhours(self):
0871         return self.__field_alarmhours.getvalue()
0872 
0873     def __setfield_alarmhours(self, value):
0874         if isinstance(value,UINT):
0875             self.__field_alarmhours=value
0876         else:
0877             self.__field_alarmhours=UINT(value,**{'sizeinbytes': 1})
0878 
0879     def __delfield_alarmhours(self): del self.__field_alarmhours
0880 
0881     alarmhours=property(__getfield_alarmhours, __setfield_alarmhours, __delfield_alarmhours, "a value of 0xFF indicates not set")
0882 
0883     def __getfield_unknown2(self):
0884         return self.__field_unknown2.getvalue()
0885 
0886     def __setfield_unknown2(self, value):
0887         if isinstance(value,UINT):
0888             self.__field_unknown2=value
0889         else:
0890             self.__field_unknown2=UINT(value,**{'sizeinbytes': 1})
0891 
0892     def __delfield_unknown2(self): del self.__field_unknown2
0893 
0894     unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None)
0895 
0896     def iscontainer(self):
0897         return True
0898 
0899     def containerelements(self):
0900         yield ('pos', self.__field_pos, "position within file, used as an event id")
0901         yield ('description', self.__field_description, None)
0902         yield ('start', self.__field_start, None)
0903         yield ('end', self.__field_end, None)
0904         yield ('repeat', self.__field_repeat, None)
0905         yield ('alarmindex_vibrate', self.__field_alarmindex_vibrate, None)
0906         yield ('ringtone', self.__field_ringtone, None)
0907         yield ('unknown1', self.__field_unknown1, None)
0908         yield ('alarmminutes', self.__field_alarmminutes, "a value of 0xFF indicates not set")
0909         yield ('alarmhours', self.__field_alarmhours, "a value of 0xFF indicates not set")
0910         yield ('unknown2', self.__field_unknown2, None)
0911 
0912 
0913 
0914 
0915 class schedulefile(BaseProtogenClass):
0916     __fields=['numactiveitems', 'events']
0917 
0918     def __init__(self, *args, **kwargs):
0919         dict={}
0920         # What was supplied to this function
0921         dict.update(kwargs)
0922         # Parent constructor
0923         super(schedulefile,self).__init__(**dict)
0924         if self.__class__ is schedulefile:
0925             self._update(args,dict)
0926 
0927 
0928     def getfields(self):
0929         return self.__fields
0930 
0931 
0932     def _update(self, args, kwargs):
0933         super(schedulefile,self)._update(args,kwargs)
0934         keys=kwargs.keys()
0935         for key in keys:
0936             if key in self.__fields:
0937                 setattr(self, key, kwargs[key])
0938                 del kwargs[key]
0939         # Were any unrecognized kwargs passed in?
0940         if __debug__:
0941             self._complainaboutunusedargs(schedulefile,kwargs)
0942         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0943         # Make all P fields that haven't already been constructed
0944 
0945 
0946     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0947         'Writes this packet to the supplied buffer'
0948         self._bufferstartoffset=buf.getcurrentoffset()
0949         self.__field_numactiveitems.writetobuffer(buf)
0950         try: self.__field_events
0951         except:
0952             self.__field_events=LIST(**{'elementclass': scheduleevent})
0953         self.__field_events.writetobuffer(buf)
0954         self._bufferendoffset=buf.getcurrentoffset()
0955         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0956 
0957 
0958     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0959         'Reads this packet from the supplied buffer'
0960         self._bufferstartoffset=buf.getcurrentoffset()
0961         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0962         self.__field_numactiveitems=UINT(**{'sizeinbytes': 2})
0963         self.__field_numactiveitems.readfrombuffer(buf)
0964         self.__field_events=LIST(**{'elementclass': scheduleevent})
0965         self.__field_events.readfrombuffer(buf)
0966         self._bufferendoffset=buf.getcurrentoffset()
0967 
0968 
0969     def __getfield_numactiveitems(self):
0970         return self.__field_numactiveitems.getvalue()
0971 
0972     def __setfield_numactiveitems(self, value):
0973         if isinstance(value,UINT):
0974             self.__field_numactiveitems=value
0975         else:
0976             self.__field_numactiveitems=UINT(value,**{'sizeinbytes': 2})
0977 
0978     def __delfield_numactiveitems(self): del self.__field_numactiveitems
0979 
0980     numactiveitems=property(__getfield_numactiveitems, __setfield_numactiveitems, __delfield_numactiveitems, None)
0981 
0982     def __getfield_events(self):
0983         try: self.__field_events
0984         except:
0985             self.__field_events=LIST(**{'elementclass': scheduleevent})
0986         return self.__field_events.getvalue()
0987 
0988     def __setfield_events(self, value):
0989         if isinstance(value,LIST):
0990             self.__field_events=value
0991         else:
0992             self.__field_events=LIST(value,**{'elementclass': scheduleevent})
0993 
0994     def __delfield_events(self): del self.__field_events
0995 
0996     events=property(__getfield_events, __setfield_events, __delfield_events, None)
0997 
0998     def iscontainer(self):
0999         return True
1000 
1001     def containerelements(self):
1002         yield ('numactiveitems', self.__field_numactiveitems, None)
1003         yield ('events', self.__field_events, None)
1004 
1005 
1006 
1007 
1008 class call(BaseProtogenClass):
1009     __fields=['GPStime', 'unknown2', 'duration', 'number', 'name', 'numberlength', 'pbnumbertype', 'unknown2', 'pbentrynum']
1010 
1011     def __init__(self, *args, **kwargs):
1012         dict={}
1013         # What was supplied to this function
1014         dict.update(kwargs)
1015         # Parent constructor
1016         super(call,self).__init__(**dict)
1017         if self.__class__ is call:
1018             self._update(args,dict)
1019 
1020 
1021     def getfields(self):
1022         return self.__fields
1023 
1024 
1025     def _update(self, args, kwargs):
1026         super(call,self)._update(args,kwargs)
1027         keys=kwargs.keys()
1028         for key in keys:
1029             if key in self.__fields:
1030                 setattr(self, key, kwargs[key])
1031                 del kwargs[key]
1032         # Were any unrecognized kwargs passed in?
1033         if __debug__:
1034             self._complainaboutunusedargs(call,kwargs)
1035         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1036         # Make all P fields that haven't already been constructed
1037 
1038 
1039     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1040         'Writes this packet to the supplied buffer'
1041         self._bufferstartoffset=buf.getcurrentoffset()
1042         self.__field_GPStime.writetobuffer(buf)
1043         self.__field_unknown2.writetobuffer(buf)
1044         self.__field_duration.writetobuffer(buf)
1045         self.__field_number.writetobuffer(buf)
1046         self.__field_name.writetobuffer(buf)
1047         self.__field_numberlength.writetobuffer(buf)
1048         self.__field_pbnumbertype.writetobuffer(buf)
1049         self.__field_unknown2.writetobuffer(buf)
1050         self.__field_pbentrynum.writetobuffer(buf)
1051         self._bufferendoffset=buf.getcurrentoffset()
1052         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1053 
1054 
1055     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1056         'Reads this packet from the supplied buffer'
1057         self._bufferstartoffset=buf.getcurrentoffset()
1058         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1059         self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4})
1060         self.__field_GPStime.readfrombuffer(buf)
1061         self.__field_unknown2=UINT(**{'sizeinbytes': 4})
1062         self.__field_unknown2.readfrombuffer(buf)
1063         self.__field_duration=UINT(**{'sizeinbytes': 4})
1064         self.__field_duration.readfrombuffer(buf)
1065         self.__field_number=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
1066         self.__field_number.readfrombuffer(buf)
1067         self.__field_name=USTRING(**{'sizeinbytes': 36, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
1068         self.__field_name.readfrombuffer(buf)
1069         self.__field_numberlength=UINT(**{'sizeinbytes': 2})
1070         self.__field_numberlength.readfrombuffer(buf)
1071         self.__field_pbnumbertype=UINT(**{'sizeinbytes': 1})
1072         self.__field_pbnumbertype.readfrombuffer(buf)
1073         self.__field_unknown2=UINT(**{'sizeinbytes': 3})
1074         self.__field_unknown2.readfrombuffer(buf)
1075         self.__field_pbentrynum=UINT(**{'sizeinbytes': 2})
1076         self.__field_pbentrynum.readfrombuffer(buf)
1077         self._bufferendoffset=buf.getcurrentoffset()
1078 
1079 
1080     def __getfield_GPStime(self):
1081         return self.__field_GPStime.getvalue()
1082 
1083     def __setfield_GPStime(self, value):
1084         if isinstance(value,GPSDATE):
1085             self.__field_GPStime=value
1086         else:
1087             self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4})
1088 
1089     def __delfield_GPStime(self): del self.__field_GPStime
1090 
1091     GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None)
1092 
1093     def __getfield_unknown2(self):
1094         return self.__field_unknown2.getvalue()
1095 
1096     def __setfield_unknown2(self, value):
1097         if isinstance(value,UINT):
1098             self.__field_unknown2=value
1099         else:
1100             self.__field_unknown2=UINT(value,**{'sizeinbytes': 4})
1101 
1102     def __delfield_unknown2(self): del self.__field_unknown2
1103 
1104     unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None)
1105 
1106     def __getfield_duration(self):
1107         return self.__field_duration.getvalue()
1108 
1109     def __setfield_duration(self, value):
1110         if isinstance(value,UINT):
1111             self.__field_duration=value
1112         else:
1113             self.__field_duration=UINT(value,**{'sizeinbytes': 4})
1114 
1115     def __delfield_duration(self): del self.__field_duration
1116 
1117     duration=property(__getfield_duration, __setfield_duration, __delfield_duration, None)
1118 
1119     def __getfield_number(self):
1120         return self.__field_number.getvalue()
1121 
1122     def __setfield_number(self, value):
1123         if isinstance(value,USTRING):
1124             self.__field_number=value
1125         else:
1126             self.__field_number=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
1127 
1128     def __delfield_number(self): del self.__field_number
1129 
1130     number=property(__getfield_number, __setfield_number, __delfield_number, None)
1131 
1132     def __getfield_name(self):
1133         return self.__field_name.getvalue()
1134 
1135     def __setfield_name(self, value):
1136         if isinstance(value,USTRING):
1137             self.__field_name=value
1138         else:
1139             self.__field_name=USTRING(value,**{'sizeinbytes': 36, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
1140 
1141     def __delfield_name(self): del self.__field_name
1142 
1143     name=property(__getfield_name, __setfield_name, __delfield_name, None)
1144 
1145     def __getfield_numberlength(self):
1146         return self.__field_numberlength.getvalue()
1147 
1148     def __setfield_numberlength(self, value):
1149         if isinstance(value,UINT):
1150             self.__field_numberlength=value
1151         else:
1152             self.__field_numberlength=UINT(value,**{'sizeinbytes': 2})
1153 
1154     def __delfield_numberlength(self): del self.__field_numberlength
1155 
1156     numberlength=property(__getfield_numberlength, __setfield_numberlength, __delfield_numberlength, None)
1157 
1158     def __getfield_pbnumbertype(self):
1159         return self.__field_pbnumbertype.getvalue()
1160 
1161     def __setfield_pbnumbertype(self, value):
1162         if isinstance(value,UINT):
1163             self.__field_pbnumbertype=value
1164         else:
1165             self.__field_pbnumbertype=UINT(value,**{'sizeinbytes': 1})
1166 
1167     def __delfield_pbnumbertype(self): del self.__field_pbnumbertype
1168 
1169     pbnumbertype=property(__getfield_pbnumbertype, __setfield_pbnumbertype, __delfield_pbnumbertype, None)
1170 
1171     def __getfield_unknown2(self):
1172         return self.__field_unknown2.getvalue()
1173 
1174     def __setfield_unknown2(self, value):
1175         if isinstance(value,UINT):
1176             self.__field_unknown2=value
1177         else:
1178             self.__field_unknown2=UINT(value,**{'sizeinbytes': 3})
1179 
1180     def __delfield_unknown2(self): del self.__field_unknown2
1181 
1182     unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None)
1183 
1184     def __getfield_pbentrynum(self):
1185         return self.__field_pbentrynum.getvalue()
1186 
1187     def __setfield_pbentrynum(self, value):
1188         if isinstance(value,UINT):
1189             self.__field_pbentrynum=value
1190         else:
1191             self.__field_pbentrynum=UINT(value,**{'sizeinbytes': 2})
1192 
1193     def __delfield_pbentrynum(self): del self.__field_pbentrynum
1194 
1195     pbentrynum=property(__getfield_pbentrynum, __setfield_pbentrynum, __delfield_pbentrynum, None)
1196 
1197     def iscontainer(self):
1198         return True
1199 
1200     def containerelements(self):
1201         yield ('GPStime', self.__field_GPStime, None)
1202         yield ('unknown2', self.__field_unknown2, None)
1203         yield ('duration', self.__field_duration, None)
1204         yield ('number', self.__field_number, None)
1205         yield ('name', self.__field_name, None)
1206         yield ('numberlength', self.__field_numberlength, None)
1207         yield ('pbnumbertype', self.__field_pbnumbertype, None)
1208         yield ('unknown2', self.__field_unknown2, None)
1209         yield ('pbentrynum', self.__field_pbentrynum, None)
1210 
1211 
1212 
1213 
1214 class callhistory(BaseProtogenClass):
1215     __fields=['numcalls', 'unknown1', 'calls']
1216 
1217     def __init__(self, *args, **kwargs):
1218         dict={}
1219         # What was supplied to this function
1220         dict.update(kwargs)
1221         # Parent constructor
1222         super(callhistory,self).__init__(**dict)
1223         if self.__class__ is callhistory:
1224             self._update(args,dict)
1225 
1226 
1227     def getfields(self):
1228         return self.__fields
1229 
1230 
1231     def _update(self, args, kwargs):
1232         super(callhistory,self)._update(args,kwargs)
1233         keys=kwargs.keys()
1234         for key in keys:
1235             if key in self.__fields:
1236                 setattr(self, key, kwargs[key])
1237                 del kwargs[key]
1238         # Were any unrecognized kwargs passed in?
1239         if __debug__:
1240             self._complainaboutunusedargs(callhistory,kwargs)
1241         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1242         # Make all P fields that haven't already been constructed
1243 
1244 
1245     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1246         'Writes this packet to the supplied buffer'
1247         self._bufferstartoffset=buf.getcurrentoffset()
1248         self.__field_numcalls.writetobuffer(buf)
1249         self.__field_unknown1.writetobuffer(buf)
1250         try: self.__field_calls
1251         except:
1252             self.__field_calls=LIST(**{'elementclass': call})
1253         self.__field_calls.writetobuffer(buf)
1254         self._bufferendoffset=buf.getcurrentoffset()
1255         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1256 
1257 
1258     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1259         'Reads this packet from the supplied buffer'
1260         self._bufferstartoffset=buf.getcurrentoffset()
1261         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1262         self.__field_numcalls=UINT(**{'sizeinbytes': 4})
1263         self.__field_numcalls.readfrombuffer(buf)
1264         self.__field_unknown1=UINT(**{'sizeinbytes': 1})
1265         self.__field_unknown1.readfrombuffer(buf)
1266         self.__field_calls=LIST(**{'elementclass': call})
1267         self.__field_calls.readfrombuffer(buf)
1268         self._bufferendoffset=buf.getcurrentoffset()
1269 
1270 
1271     def __getfield_numcalls(self):
1272         return self.__field_numcalls.getvalue()
1273 
1274     def __setfield_numcalls(self, value):
1275         if isinstance(value,UINT):
1276             self.__field_numcalls=value
1277         else:
1278             self.__field_numcalls=UINT(value,**{'sizeinbytes': 4})
1279 
1280     def __delfield_numcalls(self): del self.__field_numcalls
1281 
1282     numcalls=property(__getfield_numcalls, __setfield_numcalls, __delfield_numcalls, None)
1283 
1284     def __getfield_unknown1(self):
1285         return self.__field_unknown1.getvalue()
1286 
1287     def __setfield_unknown1(self, value):
1288         if isinstance(value,UINT):
1289             self.__field_unknown1=value
1290         else:
1291             self.__field_unknown1=UINT(value,**{'sizeinbytes': 1})
1292 
1293     def __delfield_unknown1(self): del self.__field_unknown1
1294 
1295     unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None)
1296 
1297     def __getfield_calls(self):
1298         try: self.__field_calls
1299         except:
1300             self.__field_calls=LIST(**{'elementclass': call})
1301         return self.__field_calls.getvalue()
1302 
1303     def __setfield_calls(self, value):
1304         if isinstance(value,LIST):
1305             self.__field_calls=value
1306         else:
1307             self.__field_calls=LIST(value,**{'elementclass': call})
1308 
1309     def __delfield_calls(self): del self.__field_calls
1310 
1311     calls=property(__getfield_calls, __setfield_calls, __delfield_calls, None)
1312 
1313     def iscontainer(self):
1314         return True
1315 
1316     def containerelements(self):
1317         yield ('numcalls', self.__field_numcalls, None)
1318         yield ('unknown1', self.__field_unknown1, None)
1319         yield ('calls', self.__field_calls, None)
1320 
1321 
1322 
1323 
1324 class msg_record(BaseProtogenClass):
1325     __fields=['unknown1', 'binary', 'unknown3', 'unknown4', 'unknown6', 'length', 'msg']
1326 
1327     def __init__(self, *args, **kwargs):
1328         dict={}
1329         # What was supplied to this function
1330         dict.update(kwargs)
1331         # Parent constructor
1332         super(msg_record,self).__init__(**dict)
1333         if self.__class__ is msg_record:
1334             self._update(args,dict)
1335 
1336 
1337     def getfields(self):
1338         return self.__fields
1339 
1340 
1341     def _update(self, args, kwargs):
1342         super(msg_record,self)._update(args,kwargs)
1343         keys=kwargs.keys()
1344         for key in keys:
1345             if key in self.__fields:
1346                 setattr(self, key, kwargs[key])
1347                 del kwargs[key]
1348         # Were any unrecognized kwargs passed in?
1349         if __debug__:
1350             self._complainaboutunusedargs(msg_record,kwargs)
1351         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1352         # Make all P fields that haven't already been constructed
1353 
1354 
1355     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1356         'Writes this packet to the supplied buffer'
1357         self._bufferstartoffset=buf.getcurrentoffset()
1358         self.__field_unknown1.writetobuffer(buf)
1359         self.__field_binary.writetobuffer(buf)
1360         self.__field_unknown3.writetobuffer(buf)
1361         self.__field_unknown4.writetobuffer(buf)
1362         self.__field_unknown6.writetobuffer(buf)
1363         self.__field_length.writetobuffer(buf)
1364         try: self.__field_msg
1365         except:
1366             self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx8100_179, 'length': 219})
1367         self.__field_msg.writetobuffer(buf)
1368         self._bufferendoffset=buf.getcurrentoffset()
1369         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1370 
1371 
1372     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1373         'Reads this packet from the supplied buffer'
1374         self._bufferstartoffset=buf.getcurrentoffset()
1375         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1376         self.__field_unknown1=UINT(**{'sizeinbytes': 1})
1377         self.__field_unknown1.readfrombuffer(buf)
1378         self.__field_binary=UINT(**{'sizeinbytes': 1})
1379         self.__field_binary.readfrombuffer(buf)
1380         self.__field_unknown3=UINT(**{'sizeinbytes': 1})
1381         self.__field_unknown3.readfrombuffer(buf)
1382         self.__field_unknown4=UINT(**{'sizeinbytes': 1})
1383         self.__field_unknown4.readfrombuffer(buf)
1384         self.__field_unknown6=UINT(**{'sizeinbytes': 1})
1385         self.__field_unknown6.readfrombuffer(buf)
1386         self.__field_length=UINT(**{'sizeinbytes': 1})
1387         self.__field_length.readfrombuffer(buf)
1388         self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx8100_179, 'length': 219})
1389         self.__field_msg.readfrombuffer(buf)
1390         self._bufferendoffset=buf.getcurrentoffset()
1391 
1392 
1393     def __getfield_unknown1(self):
1394         return self.__field_unknown1.getvalue()
1395 
1396     def __setfield_unknown1(self, value):
1397         if isinstance(value,UINT):
1398             self.__field_unknown1=value
1399         else:
1400             self.__field_unknown1=UINT(value,**{'sizeinbytes': 1})
1401 
1402     def __delfield_unknown1(self): del self.__field_unknown1
1403 
1404     unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None)
1405 
1406     def __getfield_binary(self):
1407         return self.__field_binary.getvalue()
1408 
1409     def __setfield_binary(self, value):
1410         if isinstance(value,UINT):
1411             self.__field_binary=value
1412         else:
1413             self.__field_binary=UINT(value,**{'sizeinbytes': 1})
1414 
1415     def __delfield_binary(self): del self.__field_binary
1416 
1417     binary=property(__getfield_binary, __setfield_binary, __delfield_binary, None)
1418 
1419     def __getfield_unknown3(self):
1420         return self.__field_unknown3.getvalue()
1421 
1422     def __setfield_unknown3(self, value):
1423         if isinstance(value,UINT):
1424             self.__field_unknown3=value
1425         else:
1426             self.__field_unknown3=UINT(value,**{'sizeinbytes': 1})
1427 
1428     def __delfield_unknown3(self): del self.__field_unknown3
1429 
1430     unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None)
1431 
1432     def __getfield_unknown4(self):
1433         return self.__field_unknown4.getvalue()
1434 
1435     def __setfield_unknown4(self, value):
1436         if isinstance(value,UINT):
1437             self.__field_unknown4=value
1438         else:
1439             self.__field_unknown4=UINT(value,**{'sizeinbytes': 1})
1440 
1441     def __delfield_unknown4(self): del self.__field_unknown4
1442 
1443     unknown4=property(__getfield_unknown4, __setfield_unknown4, __delfield_unknown4, None)
1444 
1445     def __getfield_unknown6(self):
1446         return self.__field_unknown6.getvalue()
1447 
1448     def __setfield_unknown6(self, value):
1449         if isinstance(value,UINT):
1450             self.__field_unknown6=value
1451         else:
1452             self.__field_unknown6=UINT(value,**{'sizeinbytes': 1})
1453 
1454     def __delfield_unknown6(self): del self.__field_unknown6
1455 
1456     unknown6=property(__getfield_unknown6, __setfield_unknown6, __delfield_unknown6, None)
1457 
1458     def __getfield_length(self):
1459         return self.__field_length.getvalue()
1460 
1461     def __setfield_length(self, value):
1462         if isinstance(value,UINT):
1463             self.__field_length=value
1464         else:
1465             self.__field_length=UINT(value,**{'sizeinbytes': 1})
1466 
1467     def __delfield_length(self): del self.__field_length
1468 
1469     length=property(__getfield_length, __setfield_length, __delfield_length, None)
1470 
1471     def __getfield_msg(self):
1472         try: self.__field_msg
1473         except:
1474             self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx8100_179, 'length': 219})
1475         return self.__field_msg.getvalue()
1476 
1477     def __setfield_msg(self, value):
1478         if isinstance(value,LIST):
1479             self.__field_msg=value
1480         else:
1481             self.__field_msg=LIST(value,**{'elementclass': _gen_p_lgvx8100_179, 'length': 219})
1482 
1483     def __delfield_msg(self): del self.__field_msg
1484 
1485     msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None)
1486 
1487     def iscontainer(self):
1488         return True
1489 
1490     def containerelements(self):
1491         yield ('unknown1', self.__field_unknown1, None)
1492         yield ('binary', self.__field_binary, None)
1493         yield ('unknown3', self.__field_unknown3, None)
1494         yield ('unknown4', self.__field_unknown4, None)
1495         yield ('unknown6', self.__field_unknown6, None)
1496         yield ('length', self.__field_length, None)
1497         yield ('msg', self.__field_msg, None)
1498 
1499 
1500 
1501 
1502 class _gen_p_lgvx8100_179(BaseProtogenClass):
1503     'Anonymous inner class'
1504     __fields=['byte']
1505 
1506     def __init__(self, *args, **kwargs):
1507         dict={}
1508         # What was supplied to this function
1509         dict.update(kwargs)
1510         # Parent constructor
1511         super(_gen_p_lgvx8100_179,self).__init__(**dict)
1512         if self.__class__ is _gen_p_lgvx8100_179:
1513             self._update(args,dict)
1514 
1515 
1516     def getfields(self):
1517         return self.__fields
1518 
1519 
1520     def _update(self, args, kwargs):
1521         super(_gen_p_lgvx8100_179,self)._update(args,kwargs)
1522         keys=kwargs.keys()
1523         for key in keys:
1524             if key in self.__fields:
1525                 setattr(self, key, kwargs[key])
1526                 del kwargs[key]
1527         # Were any unrecognized kwargs passed in?
1528         if __debug__:
1529             self._complainaboutunusedargs(_gen_p_lgvx8100_179,kwargs)
1530         if len(args):
1531             dict2={'sizeinbytes': 1}
1532             dict2.update(kwargs)
1533             kwargs=dict2
1534             self.__field_byte=UINT(*args,**dict2)
1535         # Make all P fields that haven't already been constructed
1536 
1537 
1538     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1539         'Writes this packet to the supplied buffer'
1540         self._bufferstartoffset=buf.getcurrentoffset()
1541         self.__field_byte.writetobuffer(buf)
1542         self._bufferendoffset=buf.getcurrentoffset()
1543         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1544 
1545 
1546     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1547         'Reads this packet from the supplied buffer'
1548         self._bufferstartoffset=buf.getcurrentoffset()
1549         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1550         self.__field_byte=UINT(**{'sizeinbytes': 1})
1551         self.__field_byte.readfrombuffer(buf)
1552         self._bufferendoffset=buf.getcurrentoffset()
1553 
1554 
1555     def __getfield_byte(self):
1556         return self.__field_byte.getvalue()
1557 
1558     def __setfield_byte(self, value):
1559         if isinstance(value,UINT):
1560             self.__field_byte=value
1561         else:
1562             self.__field_byte=UINT(value,**{'sizeinbytes': 1})
1563 
1564     def __delfield_byte(self): del self.__field_byte
1565 
1566     byte=property(__getfield_byte, __setfield_byte, __delfield_byte, "individual byte of message")
1567 
1568     def iscontainer(self):
1569         return True
1570 
1571     def containerelements(self):
1572         yield ('byte', self.__field_byte, "individual byte of message")
1573 
1574 
1575 
1576 
1577 class recipient_record(BaseProtogenClass):
1578     __fields=['unknown1', 'number', 'status', 'timesent', 'timereceived', 'unknown2', 'unknown3']
1579 
1580     def __init__(self, *args, **kwargs):
1581         dict={}
1582         # What was supplied to this function
1583         dict.update(kwargs)
1584         # Parent constructor
1585         super(recipient_record,self).__init__(**dict)
1586         if self.__class__ is recipient_record:
1587             self._update(args,dict)
1588 
1589 
1590     def getfields(self):
1591         return self.__fields
1592 
1593 
1594     def _update(self, args, kwargs):
1595         super(recipient_record,self)._update(args,kwargs)
1596         keys=kwargs.keys()
1597         for key in keys:
1598             if key in self.__fields:
1599                 setattr(self, key, kwargs[key])
1600                 del kwargs[key]
1601         # Were any unrecognized kwargs passed in?
1602         if __debug__:
1603             self._complainaboutunusedargs(recipient_record,kwargs)
1604         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1605         # Make all P fields that haven't already been constructed
1606 
1607 
1608     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1609         'Writes this packet to the supplied buffer'
1610         self._bufferstartoffset=buf.getcurrentoffset()
1611         self.__field_unknown1.writetobuffer(buf)
1612         self.__field_number.writetobuffer(buf)
1613         self.__field_status.writetobuffer(buf)
1614         self.__field_timesent.writetobuffer(buf)
1615         self.__field_timereceived.writetobuffer(buf)
1616         self.__field_unknown2.writetobuffer(buf)
1617         self.__field_unknown3.writetobuffer(buf)
1618         self._bufferendoffset=buf.getcurrentoffset()
1619         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1620 
1621 
1622     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1623         'Reads this packet from the supplied buffer'
1624         self._bufferstartoffset=buf.getcurrentoffset()
1625         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1626         self.__field_unknown1=DATA(**{'sizeinbytes': 45})
1627         self.__field_unknown1.readfrombuffer(buf)
1628         self.__field_number=USTRING(**{'sizeinbytes': 49})
1629         self.__field_number.readfrombuffer(buf)
1630         self.__field_status=UINT(**{'sizeinbytes': 1})
1631         self.__field_status.readfrombuffer(buf)
1632         self.__field_timesent=LGCALDATE(**{'sizeinbytes': 4})
1633         self.__field_timesent.readfrombuffer(buf)
1634         self.__field_timereceived=LGCALDATE(**{'sizeinbytes': 4})
1635         self.__field_timereceived.readfrombuffer(buf)
1636         self.__field_unknown2=UINT(**{'sizeinbytes': 1})
1637         self.__field_unknown2.readfrombuffer(buf)
1638         self.__field_unknown3=DATA(**{'sizeinbytes': 40})
1639         self.__field_unknown3.readfrombuffer(buf)
1640         self._bufferendoffset=buf.getcurrentoffset()
1641 
1642 
1643     def __getfield_unknown1(self):
1644         return self.__field_unknown1.getvalue()
1645 
1646     def __setfield_unknown1(self, value):
1647         if isinstance(value,DATA):
1648             self.__field_unknown1=value
1649         else:
1650             self.__field_unknown1=DATA(value,**{'sizeinbytes': 45})
1651 
1652     def __delfield_unknown1(self): del self.__field_unknown1
1653 
1654     unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None)
1655 
1656     def __getfield_number(self):
1657         return self.__field_number.getvalue()
1658 
1659     def __setfield_number(self, value):
1660         if isinstance(value,USTRING):
1661             self.__field_number=value
1662         else:
1663             self.__field_number=USTRING(value,**{'sizeinbytes': 49})
1664 
1665     def __delfield_number(self): del self.__field_number
1666 
1667     number=property(__getfield_number, __setfield_number, __delfield_number, None)
1668 
1669     def __getfield_status(self):
1670         return self.__field_status.getvalue()
1671 
1672     def __setfield_status(self, value):
1673         if isinstance(value,UINT):
1674             self.__field_status=value
1675         else:
1676             self.__field_status=UINT(value,**{'sizeinbytes': 1})
1677 
1678     def __delfield_status(self): del self.__field_status
1679 
1680     status=property(__getfield_status, __setfield_status, __delfield_status, None)
1681 
1682     def __getfield_timesent(self):
1683         return self.__field_timesent.getvalue()
1684 
1685     def __setfield_timesent(self, value):
1686         if isinstance(value,LGCALDATE):
1687             self.__field_timesent=value
1688         else:
1689             self.__field_timesent=LGCALDATE(value,**{'sizeinbytes': 4})
1690 
1691     def __delfield_timesent(self): del self.__field_timesent
1692 
1693     timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None)
1694 
1695     def __getfield_timereceived(self):
1696         return self.__field_timereceived.getvalue()
1697 
1698     def __setfield_timereceived(self, value):
1699         if isinstance(value,LGCALDATE):
1700             self.__field_timereceived=value
1701         else:
1702             self.__field_timereceived=LGCALDATE(value,**{'sizeinbytes': 4})
1703 
1704     def __delfield_timereceived(self): del self.__field_timereceived
1705 
1706     timereceived=property(__getfield_timereceived, __setfield_timereceived, __delfield_timereceived, None)
1707 
1708     def __getfield_unknown2(self):
1709         return self.__field_unknown2.getvalue()
1710 
1711     def __setfield_unknown2(self, value):
1712         if isinstance(value,UINT):
1713             self.__field_unknown2=value
1714         else:
1715             self.__field_unknown2=UINT(value,**{'sizeinbytes': 1})
1716 
1717     def __delfield_unknown2(self): del self.__field_unknown2
1718 
1719     unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None)
1720 
1721     def __getfield_unknown3(self):
1722         return self.__field_unknown3.getvalue()
1723 
1724     def __setfield_unknown3(self, value):
1725         if isinstance(value,DATA):
1726             self.__field_unknown3=value
1727         else:
1728             self.__field_unknown3=DATA(value,**{'sizeinbytes': 40})
1729 
1730     def __delfield_unknown3(self): del self.__field_unknown3
1731 
1732     unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None)
1733 
1734     def iscontainer(self):
1735         return True
1736 
1737     def containerelements(self):
1738         yield ('unknown1', self.__field_unknown1, None)
1739         yield ('number', self.__field_number, None)
1740         yield ('status', self.__field_status, None)
1741         yield ('timesent', self.__field_timesent, None)
1742         yield ('timereceived', self.__field_timereceived, None)
1743         yield ('unknown2', self.__field_unknown2, None)
1744         yield ('unknown3', self.__field_unknown3, None)
1745 
1746 
1747 
1748 
1749 class sms_saved(BaseProtogenClass):
1750     __fields=['outboxmsg', 'GPStime', 'outbox', 'inbox']
1751 
1752     def __init__(self, *args, **kwargs):
1753         dict={}
1754         # What was supplied to this function
1755         dict.update(kwargs)
1756         # Parent constructor
1757         super(sms_saved,self).__init__(**dict)
1758         if self.__class__ is sms_saved:
1759             self._update(args,dict)
1760 
1761 
1762     def getfields(self):
1763         return self.__fields
1764 
1765 
1766     def _update(self, args, kwargs):
1767         super(sms_saved,self)._update(args,kwargs)
1768         keys=kwargs.keys()
1769         for key in keys:
1770             if key in self.__fields:
1771                 setattr(self, key, kwargs[key])
1772                 del kwargs[key]
1773         # Were any unrecognized kwargs passed in?
1774         if __debug__:
1775             self._complainaboutunusedargs(sms_saved,kwargs)
1776         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1777         # Make all P fields that haven't already been constructed
1778 
1779 
1780     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1781         'Writes this packet to the supplied buffer'
1782         self._bufferstartoffset=buf.getcurrentoffset()
1783         self.__field_outboxmsg.writetobuffer(buf)
1784         self.__field_GPStime.writetobuffer(buf)
1785         if self.outboxmsg:
1786             self.__field_outbox.writetobuffer(buf)
1787         if not self.outboxmsg:
1788             self.__field_inbox.writetobuffer(buf)
1789         self._bufferendoffset=buf.getcurrentoffset()
1790         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1791 
1792 
1793     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1794         'Reads this packet from the supplied buffer'
1795         self._bufferstartoffset=buf.getcurrentoffset()
1796         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1797         self.__field_outboxmsg=UINT(**{'sizeinbytes': 4})
1798         self.__field_outboxmsg.readfrombuffer(buf)
1799         self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4})
1800         self.__field_GPStime.readfrombuffer(buf)
1801         if self.outboxmsg:
1802             self.__field_outbox=sms_out()
1803             self.__field_outbox.readfrombuffer(buf)
1804         if not self.outboxmsg:
1805             self.__field_inbox=sms_in()
1806             self.__field_inbox.readfrombuffer(buf)
1807         self._bufferendoffset=buf.getcurrentoffset()
1808 
1809 
1810     def __getfield_outboxmsg(self):
1811         return self.__field_outboxmsg.getvalue()
1812 
1813     def __setfield_outboxmsg(self, value):
1814         if isinstance(value,UINT):
1815             self.__field_outboxmsg=value
1816         else:
1817             self.__field_outboxmsg=UINT(value,**{'sizeinbytes': 4})
1818 
1819     def __delfield_outboxmsg(self): del self.__field_outboxmsg
1820 
1821     outboxmsg=property(__getfield_outboxmsg, __setfield_outboxmsg, __delfield_outboxmsg, None)
1822 
1823     def __getfield_GPStime(self):
1824         return self.__field_GPStime.getvalue()
1825 
1826     def __setfield_GPStime(self, value):
1827         if isinstance(value,GPSDATE):
1828             self.__field_GPStime=value
1829         else:
1830             self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4})
1831 
1832     def __delfield_GPStime(self): del self.__field_GPStime
1833 
1834     GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None)
1835 
1836     def __getfield_outbox(self):
1837         return self.__field_outbox.getvalue()
1838 
1839     def __setfield_outbox(self, value):
1840         if isinstance(value,sms_out):
1841             self.__field_outbox=value
1842         else:
1843             self.__field_outbox=sms_out(value,)
1844 
1845     def __delfield_outbox(self): del self.__field_outbox
1846 
1847     outbox=property(__getfield_outbox, __setfield_outbox, __delfield_outbox, None)
1848 
1849     def __getfield_inbox(self):
1850         return self.__field_inbox.getvalue()
1851 
1852     def __setfield_inbox(self, value):
1853         if isinstance(value,sms_in):
1854             self.__field_inbox=value
1855         else:
1856             self.__field_inbox=sms_in(value,)
1857 
1858     def __delfield_inbox(self): del self.__field_inbox
1859 
1860     inbox=property(__getfield_inbox, __setfield_inbox, __delfield_inbox, None)
1861 
1862     def iscontainer(self):
1863         return True
1864 
1865     def containerelements(self):
1866         yield ('outboxmsg', self.__field_outboxmsg, None)
1867         yield ('GPStime', self.__field_GPStime, None)
1868         if self.outboxmsg:
1869             yield ('outbox', self.__field_outbox, None)
1870         if not self.outboxmsg:
1871             yield ('inbox', self.__field_inbox, None)
1872 
1873 
1874 
1875 
1876 class sms_out(BaseProtogenClass):
1877     __fields=['index', 'unknown1', 'locked', 'timesent', 'unknown2', 'GPStime', 'subject', 'unknown4', 'num_msg_elements', 'messages', 'unknown5', 'priority', 'unknown7', 'unknown8', 'callback', 'recipients']
1878 
1879     def __init__(self, *args, **kwargs):
1880         dict={}
1881         # What was supplied to this function
1882         dict.update(kwargs)
1883         # Parent constructor
1884         super(sms_out,self).__init__(**dict)
1885         if self.__class__ is sms_out:
1886             self._update(args,dict)
1887 
1888 
1889     def getfields(self):
1890         return self.__fields
1891 
1892 
1893     def _update(self, args, kwargs):
1894         super(sms_out,self)._update(args,kwargs)
1895         keys=kwargs.keys()
1896         for key in keys:
1897             if key in self.__fields:
1898                 setattr(self, key, kwargs[key])
1899                 del kwargs[key]
1900         # Were any unrecognized kwargs passed in?
1901         if __debug__:
1902             self._complainaboutunusedargs(sms_out,kwargs)
1903         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1904         # Make all P fields that haven't already been constructed
1905 
1906 
1907     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1908         'Writes this packet to the supplied buffer'
1909         self._bufferstartoffset=buf.getcurrentoffset()
1910         self.__field_index.writetobuffer(buf)
1911         self.__field_unknown1.writetobuffer(buf)
1912         self.__field_locked.writetobuffer(buf)
1913         self.__field_timesent.writetobuffer(buf)
1914         self.__field_unknown2.writetobuffer(buf)
1915         self.__field_GPStime.writetobuffer(buf)
1916         self.__field_subject.writetobuffer(buf)
1917         self.__field_unknown4.writetobuffer(buf)
1918         self.__field_num_msg_elements.writetobuffer(buf)
1919         try: self.__field_messages
1920         except:
1921             self.__field_messages=LIST(**{'elementclass': msg_record, 'length': 7})
1922         self.__field_messages.writetobuffer(buf)
1923         self.__field_unknown5.writetobuffer(buf)
1924         self.__field_priority.writetobuffer(buf)
1925         self.__field_unknown7.writetobuffer(buf)
1926         self.__field_unknown8.writetobuffer(buf)
1927         self.__field_callback.writetobuffer(buf)
1928         try: self.__field_recipients
1929         except:
1930             self.__field_recipients=LIST(**{'elementclass': recipient_record,'length': 10})
1931         self.__field_recipients.writetobuffer(buf)
1932         self._bufferendoffset=buf.getcurrentoffset()
1933         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1934 
1935 
1936     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1937         'Reads this packet from the supplied buffer'
1938         self._bufferstartoffset=buf.getcurrentoffset()
1939         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1940         self.__field_index=UINT(**{'sizeinbytes': 4})
1941         self.__field_index.readfrombuffer(buf)
1942         self.__field_unknown1=UINT(**{'sizeinbytes': 1})
1943         self.__field_unknown1.readfrombuffer(buf)
1944         self.__field_locked=UINT(**{'sizeinbytes': 1})
1945         self.__field_locked.readfrombuffer(buf)
1946         self.__field_timesent=LGCALDATE(**{'sizeinbytes': 4})
1947         self.__field_timesent.readfrombuffer(buf)
1948         self.__field_unknown2=UINT(**{'sizeinbytes': 2})
1949         self.__field_unknown2.readfrombuffer(buf)
1950         self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4})
1951         self.__field_GPStime.readfrombuffer(buf)
1952         self.__field_subject=USTRING(**{'sizeinbytes': 21, 'encoding': PHONE_ENCODING})
1953         self.__field_subject.readfrombuffer(buf)
1954         self.__field_unknown4=UINT(**{'sizeinbytes': 1})
1955         self.__field_unknown4.readfrombuffer(buf)
1956         self.__field_num_msg_elements=UINT(**{'sizeinbytes': 1})
1957         self.__field_num_msg_elements.readfrombuffer(buf)
1958         self.__field_messages=LIST(**{'elementclass': msg_record, 'length': 7})
1959         self.__field_messages.readfrombuffer(buf)
1960         self.__field_unknown5=UINT(**{'sizeinbytes': 1})
1961         self.__field_unknown5.readfrombuffer(buf)
1962         self.__field_priority=UINT(**{'sizeinbytes': 1})
1963         self.__field_priority.readfrombuffer(buf)
1964         self.__field_unknown7=DATA(**{'sizeinbytes': 12})
1965         self.__field_unknown7.readfrombuffer(buf)
1966         self.__field_unknown8=DATA(**{'sizeinbytes': 3})
1967         self.__field_unknown8.readfrombuffer(buf)
1968         self.__field_callback=USTRING(**{'sizeinbytes': 23})
1969         self.__field_callback.readfrombuffer(buf)
1970         self.__field_recipients=LIST(**{'elementclass': recipient_record,'length': 10})
1971         self.__field_recipients.readfrombuffer(buf)
1972         self._bufferendoffset=buf.getcurrentoffset()
1973 
1974 
1975     def __getfield_index(self):
1976         return self.__field_index.getvalue()
1977 
1978     def __setfield_index(self, value):
1979         if isinstance(value,UINT):
1980             self.__field_index=value
1981         else:
1982             self.__field_index=UINT(value,**{'sizeinbytes': 4})
1983 
1984     def __delfield_index(self): del self.__field_index
1985 
1986     index=property(__getfield_index, __setfield_index, __delfield_index, None)
1987 
1988     def __getfield_unknown1(self):
1989         return self.__field_unknown1.getvalue()
1990 
1991     def __setfield_unknown1(self, value):
1992         if isinstance(value,UINT):
1993             self.__field_unknown1=value
1994         else:
1995             self.__field_unknown1=UINT(value,**{'sizeinbytes': 1})
1996 
1997     def __delfield_unknown1(self): del self.__field_unknown1
1998 
1999     unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None)
2000 
2001     def __getfield_locked(self):
2002         return self.__field_locked.getvalue()
2003 
2004     def __setfield_locked(self, value):
2005         if isinstance(value,UINT):
2006             self.__field_locked=value
2007         else:
2008             self.__field_locked=UINT(value,**{'sizeinbytes': 1})
2009 
2010     def __delfield_locked(self): del self.__field_locked
2011 
2012     locked=property(__getfield_locked, __setfield_locked, __delfield_locked, None)
2013 
2014     def __getfield_timesent(self):
2015         return self.__field_timesent.getvalue()
2016 
2017     def __setfield_timesent(self, value):
2018         if isinstance(value,LGCALDATE):
2019             self.__field_timesent=value
2020         else:
2021             self.__field_timesent=LGCALDATE(value,**{'sizeinbytes': 4})
2022 
2023     def __delfield_timesent(self): del self.__field_timesent
2024 
2025     timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None)
2026 
2027     def __getfield_unknown2(self):
2028         return self.__field_unknown2.getvalue()
2029 
2030     def __setfield_unknown2(self, value):
2031         if isinstance(value,UINT):
2032             self.__field_unknown2=value
2033         else:
2034             self.__field_unknown2=UINT(value,**{'sizeinbytes': 2})
2035 
2036     def __delfield_unknown2(self): del self.__field_unknown2
2037 
2038     unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None)
2039 
2040     def __getfield_GPStime(self):
2041         return self.__field_GPStime.getvalue()
2042 
2043     def __setfield_GPStime(self, value):
2044         if isinstance(value,GPSDATE):
2045             self.__field_GPStime=value
2046         else:
2047             self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4})
2048 
2049     def __delfield_GPStime(self): del self.__field_GPStime
2050 
2051     GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None)
2052 
2053     def __getfield_subject(self):
2054         return self.__field_subject.getvalue()
2055 
2056     def __setfield_subject(self, value):
2057         if isinstance(value,USTRING):
2058             self.__field_subject=value
2059         else:
2060             self.__field_subject=USTRING(value,**{'sizeinbytes': 21, 'encoding': PHONE_ENCODING})
2061 
2062     def __delfield_subject(self): del self.__field_subject
2063 
2064     subject=property(__getfield_subject, __setfield_subject, __delfield_subject, None)
2065 
2066     def __getfield_unknown4(self):
2067         return self.__field_unknown4.getvalue()
2068 
2069     def __setfield_unknown4(self, value):
2070         if isinstance(value,UINT):
2071             self.__field_unknown4=value
2072         else:
2073             self.__field_unknown4=UINT(value,**{'sizeinbytes': 1})
2074 
2075     def __delfield_unknown4(self): del self.__field_unknown4
2076 
2077     unknown4=property(__getfield_unknown4, __setfield_unknown4, __delfield_unknown4, None)
2078 
2079     def __getfield_num_msg_elements(self):
2080         return self.__field_num_msg_elements.getvalue()
2081 
2082     def __setfield_num_msg_elements(self, value):
2083         if isinstance(value,UINT):
2084             self.__field_num_msg_elements=value
2085         else:
2086             self.__field_num_msg_elements=UINT(value,**{'sizeinbytes': 1})
2087 
2088     def __delfield_num_msg_elements(self): del self.__field_num_msg_elements
2089 
2090     num_msg_elements=property(__getfield_num_msg_elements, __setfield_num_msg_elements, __delfield_num_msg_elements, None)
2091 
2092     def __getfield_messages(self):
2093         try: self.__field_messages
2094         except:
2095             self.__field_messages=LIST(**{'elementclass': msg_record, 'length': 7})
2096         return self.__field_messages.getvalue()
2097 
2098     def __setfield_messages(self, value):
2099         if isinstance(value,LIST):
2100             self.__field_messages=value
2101         else:
2102             self.__field_messages=LIST(value,**{'elementclass': msg_record, 'length': 7})
2103 
2104     def __delfield_messages(self): del self.__field_messages
2105 
2106     messages=property(__getfield_messages, __setfield_messages, __delfield_messages, None)
2107 
2108     def __getfield_unknown5(self):
2109         return self.__field_unknown5.getvalue()
2110 
2111     def __setfield_unknown5(self, value):
2112         if isinstance(value,UINT):
2113             self.__field_unknown5=value
2114         else:
2115             self.__field_unknown5=UINT(value,**{'sizeinbytes': 1})
2116 
2117     def __delfield_unknown5(self): del self.__field_unknown5
2118 
2119     unknown5=property(__getfield_unknown5, __setfield_unknown5, __delfield_unknown5, None)
2120 
2121     def __getfield_priority(self):
2122         return self.__field_priority.getvalue()
2123 
2124     def __setfield_priority(self, value):
2125         if isinstance(value,UINT):
2126             self.__field_priority=value
2127         else:
2128             self.__field_priority=UINT(value,**{'sizeinbytes': 1})
2129 
2130     def __delfield_priority(self): del self.__field_priority
2131 
2132     priority=property(__getfield_priority, __setfield_priority, __delfield_priority, None)
2133 
2134     def __getfield_unknown7(self):
2135         return self.__field_unknown7.getvalue()
2136 
2137     def __setfield_unknown7(self, value):
2138         if isinstance(value,DATA):
2139             self.__field_unknown7=value
2140         else:
2141             self.__field_unknown7=DATA(value,**{'sizeinbytes': 12})
2142 
2143     def __delfield_unknown7(self): del self.__field_unknown7
2144 
2145     unknown7=property(__getfield_unknown7, __setfield_unknown7, __delfield_unknown7, None)
2146 
2147     def __getfield_unknown8(self):
2148         return self.__field_unknown8.getvalue()
2149 
2150     def __setfield_unknown8(self, value):
2151         if isinstance(value,DATA):
2152             self.__field_unknown8=value
2153         else:
2154             self.__field_unknown8=DATA(value,**{'sizeinbytes': 3})
2155 
2156     def __delfield_unknown8(self): del self.__field_unknown8
2157 
2158     unknown8=property(__getfield_unknown8, __setfield_unknown8, __delfield_unknown8, None)
2159 
2160     def __getfield_callback(self):
2161         return self.__field_callback.getvalue()
2162 
2163     def __setfield_callback(self, value):
2164         if isinstance(value,USTRING):
2165             self.__field_callback=value
2166         else:
2167             self.__field_callback=USTRING(value,**{'sizeinbytes': 23})
2168 
2169     def __delfield_callback(self): del self.__field_callback
2170 
2171     callback=property(__getfield_callback, __setfield_callback, __delfield_callback, None)
2172 
2173     def __getfield_recipients(self):
2174         try: self.__field_recipients
2175         except:
2176             self.__field_recipients=LIST(**{'elementclass': recipient_record,'length': 10})
2177         return self.__field_recipients.getvalue()
2178 
2179     def __setfield_recipients(self, value):
2180         if isinstance(value,LIST):
2181             self.__field_recipients=value
2182         else:
2183             self.__field_recipients=LIST(value,**{'elementclass': recipient_record,'length': 10})
2184 
2185     def __delfield_recipients(self): del self.__field_recipients
2186 
2187     recipients=property(__getfield_recipients, __setfield_recipients, __delfield_recipients, None)
2188 
2189     def iscontainer(self):
2190         return True
2191 
2192     def containerelements(self):
2193         yield ('index', self.__field_index, None)
2194         yield ('unknown1', self.__field_unknown1, None)
2195         yield ('locked', self.__field_locked, None)
2196         yield ('timesent', self.__field_timesent, None)
2197         yield ('unknown2', self.__field_unknown2, None)
2198         yield ('GPStime', self.__field_GPStime, None)
2199         yield ('subject', self.__field_subject, None)
2200         yield ('unknown4', self.__field_unknown4, None)
2201         yield ('num_msg_elements', self.__field_num_msg_elements, None)
2202         yield ('messages', self.__field_messages, None)
2203         yield ('unknown5', self.__field_unknown5, None)
2204         yield ('priority', self.__field_priority, None)
2205         yield ('unknown7', self.__field_unknown7, None)
2206         yield ('unknown8', self.__field_unknown8, None)
2207         yield ('callback', self.__field_callback, None)
2208         yield ('recipients', self.__field_recipients, None)
2209 
2210 
2211 
2212 
2213 class SMSINBOXMSGFRAGMENT(BaseProtogenClass):
2214     __fields=['msg']
2215 
2216     def __init__(self, *args, **kwargs):
2217         dict={}
2218         # What was supplied to this function
2219         dict.update(kwargs)
2220         # Parent constructor
2221         super(SMSINBOXMSGFRAGMENT,self).__init__(**dict)
2222         if self.__class__ is SMSINBOXMSGFRAGMENT:
2223             self._update(args,dict)
2224 
2225 
2226     def getfields(self):
2227         return self.__fields
2228 
2229 
2230     def _update(self, args, kwargs):
2231         super(SMSINBOXMSGFRAGMENT,self)._update(args,kwargs)
2232         keys=kwargs.keys()
2233         for key in keys:
2234             if key in self.__fields:
2235                 setattr(self, key, kwargs[key])
2236                 del kwargs[key]
2237         # Were any unrecognized kwargs passed in?
2238         if __debug__:
2239             self._complainaboutunusedargs(SMSINBOXMSGFRAGMENT,kwargs)
2240         if len(args):
2241             dict2={'elementclass': _gen_p_lgvx8100_218, 'length': 181}
2242             dict2.update(kwargs)
2243             kwargs=dict2
2244             self.__field_msg=LIST(*args,**dict2)
2245         # Make all P fields that haven't already been constructed
2246 
2247 
2248     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2249         'Writes this packet to the supplied buffer'
2250         self._bufferstartoffset=buf.getcurrentoffset()
2251         try: self.__field_msg
2252         except:
2253             self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx8100_218, 'length': 181})
2254         self.__field_msg.writetobuffer(buf)
2255         self._bufferendoffset=buf.getcurrentoffset()
2256         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2257 
2258 
2259     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2260         'Reads this packet from the supplied buffer'
2261         self._bufferstartoffset=buf.getcurrentoffset()
2262         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2263         self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx8100_218, 'length': 181})
2264         self.__field_msg.readfrombuffer(buf)
2265         self._bufferendoffset=buf.getcurrentoffset()
2266 
2267 
2268     def __getfield_msg(self):
2269         try: self.__field_msg
2270         except:
2271             self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx8100_218, 'length': 181})
2272         return self.__field_msg.getvalue()
2273 
2274     def __setfield_msg(self, value):
2275         if isinstance(value,LIST):
2276             self.__field_msg=value
2277         else:
2278             self.__field_msg=LIST(value,**{'elementclass': _gen_p_lgvx8100_218, 'length': 181})
2279 
2280     def __delfield_msg(self): del self.__field_msg
2281 
2282     msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None)
2283 
2284     def iscontainer(self):
2285         return True
2286 
2287     def containerelements(self):
2288         yield ('msg', self.__field_msg, None)
2289 
2290 
2291 
2292 
2293 class _gen_p_lgvx8100_218(BaseProtogenClass):
2294     'Anonymous inner class'
2295     __fields=['byte']
2296 
2297     def __init__(self, *args, **kwargs):
2298         dict={}
2299         # What was supplied to this function
2300         dict.update(kwargs)
2301         # Parent constructor
2302         super(_gen_p_lgvx8100_218,self).__init__(**dict)
2303         if self.__class__ is _gen_p_lgvx8100_218:
2304             self._update(args,dict)
2305 
2306 
2307     def getfields(self):
2308         return self.__fields
2309 
2310 
2311     def _update(self, args, kwargs):
2312         super(_gen_p_lgvx8100_218,self)._update(args,kwargs)
2313         keys=kwargs.keys()
2314         for key in keys:
2315             if key in self.__fields:
2316                 setattr(self, key, kwargs[key])
2317                 del kwargs[key]
2318         # Were any unrecognized kwargs passed in?
2319         if __debug__:
2320             self._complainaboutunusedargs(_gen_p_lgvx8100_218,kwargs)
2321         if len(args):
2322             dict2={'sizeinbytes': 1}
2323             dict2.update(kwargs)
2324             kwargs=dict2
2325             self.__field_byte=UINT(*args,**dict2)
2326         # Make all P fields that haven't already been constructed
2327 
2328 
2329     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2330         'Writes this packet to the supplied buffer'
2331         self._bufferstartoffset=buf.getcurrentoffset()
2332         self.__field_byte.writetobuffer(buf)
2333         self._bufferendoffset=buf.getcurrentoffset()
2334         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2335 
2336 
2337     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2338         'Reads this packet from the supplied buffer'
2339         self._bufferstartoffset=buf.getcurrentoffset()
2340         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2341         self.__field_byte=UINT(**{'sizeinbytes': 1})
2342         self.__field_byte.readfrombuffer(buf)
2343         self._bufferendoffset=buf.getcurrentoffset()
2344 
2345 
2346     def __getfield_byte(self):
2347         return self.__field_byte.getvalue()
2348 
2349     def __setfield_byte(self, value):
2350         if isinstance(value,UINT):
2351             self.__field_byte=value
2352         else:
2353             self.__field_byte=UINT(value,**{'sizeinbytes': 1})
2354 
2355     def __delfield_byte(self): del self.__field_byte
2356 
2357     byte=property(__getfield_byte, __setfield_byte, __delfield_byte, "individual byte of message")
2358 
2359     def iscontainer(self):
2360         return True
2361 
2362     def containerelements(self):
2363         yield ('byte', self.__field_byte, "individual byte of message")
2364 
2365 
2366 
2367 
2368 class sms_in(BaseProtogenClass):
2369     __fields=['msg_index1', 'msg_index2', 'unknown2', 'timesent', 'unknown', 'callback_length', 'callback', 'sender_length', 'sender', 'unknown3', 'lg_time', 'unknown4', 'GPStime', 'unknown5', 'read', 'locked', 'unknown8', 'priority', 'unknown11', 'subject', 'bin_header1', 'bin_header2', 'unknown6', 'multipartID', 'unknown14', 'bin_header3', 'num_msg_elements', 'msglengths', 'msgs', 'unknown12', 'senders_name', 'unknown9']
2370 
2371     def __init__(self, *args, **kwargs):
2372         dict={}
2373         # What was supplied to this function
2374         dict.update(kwargs)
2375         # Parent constructor
2376         super(sms_in,self).__init__(**dict)
2377         if self.__class__ is sms_in:
2378             self._update(args,dict)
2379 
2380 
2381     def getfields(self):
2382         return self.__fields
2383 
2384 
2385     def _update(self, args, kwargs):
2386         super(sms_in,self)._update(args,kwargs)
2387         keys=kwargs.keys()
2388         for key in keys:
2389             if key in self.__fields:
2390                 setattr(self, key, kwargs[key])
2391                 del kwargs[key]
2392         # Were any unrecognized kwargs passed in?
2393         if __debug__:
2394             self._complainaboutunusedargs(sms_in,kwargs)
2395         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2396         # Make all P fields that haven't already been constructed
2397 
2398 
2399     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2400         'Writes this packet to the supplied buffer'
2401         self._bufferstartoffset=buf.getcurrentoffset()
2402         self.__field_msg_index1.writetobuffer(buf)
2403         self.__field_msg_index2.writetobuffer(buf)
2404         self.__field_unknown2.writetobuffer(buf)
2405         self.__field_timesent.writetobuffer(buf)
2406         self.__field_unknown.writetobuffer(buf)
2407         self.__field_callback_length.writetobuffer(buf)
2408         self.__field_callback.writetobuffer(buf)
2409         self.__field_sender_length.writetobuffer(buf)
2410         try: self.__field_sender
2411         except:
2412             self.__field_sender=LIST(**{'elementclass': _gen_p_lgvx8100_230, 'length': 38})
2413         self.__field_sender.writetobuffer(buf)
2414         self.__field_unknown3.writetobuffer(buf)
2415         self.__field_lg_time.writetobuffer(buf)
2416         self.__field_unknown4.writetobuffer(buf)
2417         self.__field_GPStime.writetobuffer(buf)
2418         self.__field_unknown5.writetobuffer(buf)
2419         self.__field_read.writetobuffer(buf)
2420         self.__field_locked.writetobuffer(buf)
2421         self.__field_unknown8.writetobuffer(buf)
2422         self.__field_priority.writetobuffer(buf)
2423         self.__field_unknown11.writetobuffer(buf)
2424         self.__field_subject.writetobuffer(buf)
2425         self.__field_bin_header1.writetobuffer(buf)
2426         self.__field_bin_header2.writetobuffer(buf)
2427         self.__field_unknown6.writetobuffer(buf)
2428         self.__field_multipartID.writetobuffer(buf)
2429         self.__field_unknown14.writetobuffer(buf)
2430         self.__field_bin_header3.writetobuffer(buf)
2431         self.__field_num_msg_elements.writetobuffer(buf)
2432         try: self.__field_msglengths
2433         except:
2434             self.__field_msglengths=LIST(**{'elementclass': _gen_p_lgvx8100_250, 'length': 20})
2435         self.__field_msglengths.writetobuffer(buf)
2436         try: self.__field_msgs
2437         except:
2438             self.__field_msgs=LIST(**{'length': 20, 'elementclass': SMSINBOXMSGFRAGMENT})
2439         self.__field_msgs.writetobuffer(buf)
2440         self.__field_unknown12.writetobuffer(buf)
2441         self.__field_senders_name.writetobuffer(buf)
2442         self.__field_unknown9.writetobuffer(buf)
2443         self._bufferendoffset=buf.getcurrentoffset()
2444         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2445 
2446 
2447     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2448         'Reads this packet from the supplied buffer'
2449         self._bufferstartoffset=buf.getcurrentoffset()
2450         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2451         self.__field_msg_index1=UINT(**{'sizeinbytes': 4})
2452         self.__field_msg_index1.readfrombuffer(buf)
2453         self.__field_msg_index2=UINT(**{'sizeinbytes': 4})
2454         self.__field_msg_index2.readfrombuffer(buf)
2455         self.__field_unknown2=UINT(**{'sizeinbytes': 2})
2456         self.__field_unknown2.readfrombuffer(buf)
2457         self.__field_timesent=SMSDATE(**{'sizeinbytes': 6})
2458         self.__field_timesent.readfrombuffer(buf)
2459         self.__field_unknown=UINT(**{'sizeinbytes': 3})
2460         self.__field_unknown.readfrombuffer(buf)
2461         self.__field_callback_length=UINT(**{'sizeinbytes': 1})
2462         self.__field_callback_length.readfrombuffer(buf)
2463         self.__field_callback=USTRING(**{'sizeinbytes': 38})
2464         self.__field_callback.readfrombuffer(buf)
2465         self.__field_sender_length=UINT(**{'sizeinbytes': 1})
2466         self.__field_sender_length.readfrombuffer(buf)
2467         self.__field_sender=LIST(**{'elementclass': _gen_p_lgvx8100_230, 'length': 38})
2468         self.__field_sender.readfrombuffer(buf)
2469         self.__field_unknown3=DATA(**{'sizeinbytes': 12})
2470         self.__field_unknown3.readfrombuffer(buf)
2471         self.__field_lg_time=LGCALDATE(**{'sizeinbytes': 4})
2472         self.__field_lg_time.readfrombuffer(buf)
2473         self.__field_unknown4=UINT(**{'sizeinbytes': 3})
2474         self.__field_unknown4.readfrombuffer(buf)
2475         self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4})
2476         self.__field_GPStime.readfrombuffer(buf)
2477         self.__field_unknown5=UINT(**{'sizeinbytes': 4})
2478         self.__field_unknown5.readfrombuffer(buf)
2479         self.__field_read=UINT(**{'sizeinbytes': 1})
2480         self.__field_read.readfrombuffer(buf)
2481         self.__field_locked=UINT(**{'sizeinbytes': 1})
2482         self.__field_locked.readfrombuffer(buf)
2483         self.__field_unknown8=UINT(**{'sizeinbytes': 2})
2484         self.__field_unknown8.readfrombuffer(buf)
2485         self.__field_priority=UINT(**{'sizeinbytes': 1})
2486         self.__field_priority.readfrombuffer(buf)
2487         self.__field_unknown11=DATA(**{'sizeinbytes': 6})
2488         self.__field_unknown11.readfrombuffer(buf)
2489         self.__field_subject=USTRING(**{'sizeinbytes': 21, 'encoding': PHONE_ENCODING})
2490         self.__field_subject.readfrombuffer(buf)
2491         self.__field_bin_header1=UINT(**{'sizeinbytes': 1})
2492         self.__field_bin_header1.readfrombuffer(buf)
2493         self.__field_bin_header2=UINT(**{'sizeinbytes': 1})
2494         self.__field_bin_header2.readfrombuffer(buf)
2495         self.__field_unknown6=UINT(**{'sizeinbytes': 2})
2496         self.__field_unknown6.readfrombuffer(buf)
2497         self.__field_multipartID=UINT(**{'sizeinbytes': 2})
2498         self.__field_multipartID.readfrombuffer(buf)
2499         self.__field_unknown14=UINT(**{'sizeinbytes': 2})
2500         self.__field_unknown14.readfrombuffer(buf)
2501         self.__field_bin_header3=UINT(**{'sizeinbytes': 1})
2502         self.__field_bin_header3.readfrombuffer(buf)
2503         self.__field_num_msg_elements=UINT(**{'sizeinbytes': 1})
2504         self.__field_num_msg_elements.readfrombuffer(buf)
2505         self.__field_msglengths=LIST(**{'elementclass': _gen_p_lgvx8100_250, 'length': 20})
2506         self.__field_msglengths.readfrombuffer(buf)
2507         self.__field_msgs=LIST(**{'length': 20, 'elementclass': SMSINBOXMSGFRAGMENT})
2508         self.__field_msgs.readfrombuffer(buf)
2509         self.__field_unknown12=DATA(**{'sizeinbytes': 60})
2510         self.__field_unknown12.readfrombuffer(buf)
2511         self.__field_senders_name=USTRING(**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING})
2512         self.__field_senders_name.readfrombuffer(buf)
2513         self.__field_unknown9=DATA(**{'sizeinbytes': 169})
2514         self.__field_unknown9.readfrombuffer(buf)
2515         self._bufferendoffset=buf.getcurrentoffset()
2516 
2517 
2518     def __getfield_msg_index1(self):
2519         return self.__field_msg_index1.getvalue()
2520 
2521     def __setfield_msg_index1(self, value):
2522         if isinstance(value,UINT):
2523             self.__field_msg_index1=value
2524         else:
2525             self.__field_msg_index1=UINT(value,**{'sizeinbytes': 4})
2526 
2527     def __delfield_msg_index1(self): del self.__field_msg_index1
2528 
2529     msg_index1=property(__getfield_msg_index1, __setfield_msg_index1, __delfield_msg_index1, None)
2530 
2531     def __getfield_msg_index2(self):
2532         return self.__field_msg_index2.getvalue()
2533 
2534     def __setfield_msg_index2(self, value):
2535         if isinstance(value,UINT):
2536             self.__field_msg_index2=value
2537         else:
2538             self.__field_msg_index2=UINT(value,**{'sizeinbytes': 4})
2539 
2540     def __delfield_msg_index2(self): del self.__field_msg_index2
2541 
2542     msg_index2=property(__getfield_msg_index2, __setfield_msg_index2, __delfield_msg_index2, None)
2543 
2544     def __getfield_unknown2(self):
2545         return self.__field_unknown2.getvalue()
2546 
2547     def __setfield_unknown2(self, value):
2548         if isinstance(value,UINT):
2549             self.__field_unknown2=value
2550         else:
2551             self.__field_unknown2=UINT(value,**{'sizeinbytes': 2})
2552 
2553     def __delfield_unknown2(self): del self.__field_unknown2
2554 
2555     unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None)
2556 
2557     def __getfield_timesent(self):
2558         return self.__field_timesent.getvalue()
2559 
2560     def __setfield_timesent(self, value):
2561         if isinstance(value,SMSDATE):
2562             self.__field_timesent=value
2563         else:
2564             self.__field_timesent=SMSDATE(value,**{'sizeinbytes': 6})
2565 
2566     def __delfield_timesent(self): del self.__field_timesent
2567 
2568     timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None)
2569 
2570     def __getfield_unknown(self):
2571         return self.__field_unknown.getvalue()
2572 
2573     def __setfield_unknown(self, value):
2574         if isinstance(value,UINT):
2575             self.__field_unknown=value
2576         else:
2577             self.__field_unknown=UINT(value,**{'sizeinbytes': 3})
2578 
2579     def __delfield_unknown(self): del self.__field_unknown
2580 
2581     unknown=property(__getfield_unknown, __setfield_unknown, __delfield_unknown, None)
2582 
2583     def __getfield_callback_length(self):
2584         return self.__field_callback_length.getvalue()
2585 
2586     def __setfield_callback_length(self, value):
2587         if isinstance(value,UINT):
2588             self.__field_callback_length=value
2589         else:
2590             self.__field_callback_length=UINT(value,**{'sizeinbytes': 1})
2591 
2592     def __delfield_callback_length(self): del self.__field_callback_length
2593 
2594     callback_length=property(__getfield_callback_length, __setfield_callback_length, __delfield_callback_length, None)
2595 
2596     def __getfield_callback(self):
2597         return self.__field_callback.getvalue()
2598 
2599     def __setfield_callback(self, value):
2600         if isinstance(value,USTRING):
2601             self.__field_callback=value
2602         else:
2603             self.__field_callback=USTRING(value,**{'sizeinbytes': 38})
2604 
2605     def __delfield_callback(self): del self.__field_callback
2606 
2607     callback=property(__getfield_callback, __setfield_callback, __delfield_callback, None)
2608 
2609     def __getfield_sender_length(self):
2610         return self.__field_sender_length.getvalue()
2611 
2612     def __setfield_sender_length(self, value):
2613         if isinstance(value,UINT):
2614             self.__field_sender_length=value
2615         else:
2616             self.__field_sender_length=UINT(value,**{'sizeinbytes': 1})
2617 
2618     def __delfield_sender_length(self): del self.__field_sender_length
2619 
2620     sender_length=property(__getfield_sender_length, __setfield_sender_length, __delfield_sender_length, None)
2621 
2622     def __getfield_sender(self):
2623         try: self.__field_sender
2624         except:
2625             self.__field_sender=LIST(**{'elementclass': _gen_p_lgvx8100_230, 'length': 38})
2626         return self.__field_sender.getvalue()
2627 
2628     def __setfield_sender(self, value):
2629         if isinstance(value,LIST):
2630             self.__field_sender=value
2631         else:
2632             self.__field_sender=LIST(value,**{'elementclass': _gen_p_lgvx8100_230, 'length': 38})
2633 
2634     def __delfield_sender(self): del self.__field_sender
2635 
2636     sender=property(__getfield_sender, __setfield_sender, __delfield_sender, None)
2637 
2638     def __getfield_unknown3(self):
2639         return self.__field_unknown3.getvalue()
2640 
2641     def __setfield_unknown3(self, value):
2642         if isinstance(value,DATA):
2643             self.__field_unknown3=value
2644         else:
2645             self.__field_unknown3=DATA(value,**{'sizeinbytes': 12})
2646 
2647     def __delfield_unknown3(self): del self.__field_unknown3
2648 
2649     unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None)
2650 
2651     def __getfield_lg_time(self):
2652         return self.__field_lg_time.getvalue()
2653 
2654     def __setfield_lg_time(self, value):
2655         if isinstance(value,LGCALDATE):
2656             self.__field_lg_time=value
2657         else:
2658             self.__field_lg_time=LGCALDATE(value,**{'sizeinbytes': 4})
2659 
2660     def __delfield_lg_time(self): del self.__field_lg_time
2661 
2662     lg_time=property(__getfield_lg_time, __setfield_lg_time, __delfield_lg_time, None)
2663 
2664     def __getfield_unknown4(self):
2665         return self.__field_unknown4.getvalue()
2666 
2667     def __setfield_unknown4(self, value):
2668         if isinstance(value,UINT):
2669             self.__field_unknown4=value
2670         else:
2671             self.__field_unknown4=UINT(value,**{'sizeinbytes': 3})
2672 
2673     def __delfield_unknown4(self): del self.__field_unknown4
2674 
2675     unknown4=property(__getfield_unknown4, __setfield_unknown4, __delfield_unknown4, None)
2676 
2677     def __getfield_GPStime(self):
2678         return self.__field_GPStime.getvalue()
2679 
2680     def __setfield_GPStime(self, value):
2681         if isinstance(value,GPSDATE):
2682             self.__field_GPStime=value
2683         else:
2684             self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4})
2685 
2686     def __delfield_GPStime(self): del self.__field_GPStime
2687 
2688     GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None)
2689 
2690     def __getfield_unknown5(self):
2691         return self.__field_unknown5.getvalue()
2692 
2693     def __setfield_unknown5(self, value):
2694         if isinstance(value,UINT):
2695             self.__field_unknown5=value
2696         else:
2697             self.__field_unknown5=UINT(value,**{'sizeinbytes': 4})
2698 
2699     def __delfield_unknown5(self): del self.__field_unknown5
2700 
2701     unknown5=property(__getfield_unknown5, __setfield_unknown5, __delfield_unknown5, None)
2702 
2703     def __getfield_read(self):
2704         return self.__field_read.getvalue()
2705 
2706     def __setfield_read(self, value):
2707         if isinstance(value,UINT):
2708             self.__field_read=value
2709         else:
2710             self.__field_read=UINT(value,**{'sizeinbytes': 1})
2711 
2712     def __delfield_read(self): del self.__field_read
2713 
2714     read=property(__getfield_read, __setfield_read, __delfield_read, None)
2715 
2716     def __getfield_locked(self):
2717         return self.__field_locked.getvalue()
2718 
2719     def __setfield_locked(self, value):
2720         if isinstance(value,UINT):
2721             self.__field_locked=value
2722         else:
2723             self.__field_locked=UINT(value,**{'sizeinbytes': 1})
2724 
2725     def __delfield_locked(self): del self.__field_locked
2726 
2727     locked=property(__getfield_locked, __setfield_locked, __delfield_locked, None)
2728 
2729     def __getfield_unknown8(self):
2730         return self.__field_unknown8.getvalue()
2731 
2732     def __setfield_unknown8(self, value):
2733         if isinstance(value,UINT):
2734             self.__field_unknown8=value
2735         else:
2736             self.__field_unknown8=UINT(value,**{'sizeinbytes': 2})
2737 
2738     def __delfield_unknown8(self): del self.__field_unknown8
2739 
2740     unknown8=property(__getfield_unknown8, __setfield_unknown8, __delfield_unknown8, None)
2741 
2742     def __getfield_priority(self):
2743         return self.__field_priority.getvalue()
2744 
2745     def __setfield_priority(self, value):
2746         if isinstance(value,UINT):
2747             self.__field_priority=value
2748         else:
2749             self.__field_priority=UINT(value,**{'sizeinbytes': 1})
2750 
2751     def __delfield_priority(self): del self.__field_priority
2752 
2753     priority=property(__getfield_priority, __setfield_priority, __delfield_priority, None)
2754 
2755     def __getfield_unknown11(self):
2756         return self.__field_unknown11.getvalue()
2757 
2758     def __setfield_unknown11(self, value):
2759         if isinstance(value,DATA):
2760             self.__field_unknown11=value
2761         else:
2762             self.__field_unknown11=DATA(value,**{'sizeinbytes': 6})
2763 
2764     def __delfield_unknown11(self): del self.__field_unknown11
2765 
2766     unknown11=property(__getfield_unknown11, __setfield_unknown11, __delfield_unknown11, None)
2767 
2768     def __getfield_subject(self):
2769         return self.__field_subject.getvalue()
2770 
2771     def __setfield_subject(self, value):
2772         if isinstance(value,USTRING):
2773             self.__field_subject=value
2774         else:
2775             self.__field_subject=USTRING(value,**{'sizeinbytes': 21, 'encoding': PHONE_ENCODING})
2776 
2777     def __delfield_subject(self): del self.__field_subject
2778 
2779     subject=property(__getfield_subject, __setfield_subject, __delfield_subject, None)
2780 
2781     def __getfield_bin_header1(self):
2782         return self.__field_bin_header1.getvalue()
2783 
2784     def __setfield_bin_header1(self, value):
2785         if isinstance(value,UINT):
2786             self.__field_bin_header1=value
2787         else:
2788             self.__field_bin_header1=UINT(value,**{'sizeinbytes': 1})
2789 
2790     def __delfield_bin_header1(self): del self.__field_bin_header1
2791 
2792     bin_header1=property(__getfield_bin_header1, __setfield_bin_header1, __delfield_bin_header1, None)
2793 
2794     def __getfield_bin_header2(self):
2795         return self.__field_bin_header2.getvalue()
2796 
2797     def __setfield_bin_header2(self, value):
2798         if isinstance(value,UINT):
2799             self.__field_bin_header2=value
2800         else:
2801             self.__field_bin_header2=UINT(value,**{'sizeinbytes': 1})
2802 
2803     def __delfield_bin_header2(self): del self.__field_bin_header2
2804 
2805     bin_header2=property(__getfield_bin_header2, __setfield_bin_header2, __delfield_bin_header2, None)
2806 
2807     def __getfield_unknown6(self):
2808         return self.__field_unknown6.getvalue()
2809 
2810     def __setfield_unknown6(self, value):
2811         if isinstance(value,UINT):
2812             self.__field_unknown6=value
2813         else:
2814             self.__field_unknown6=UINT(value,**{'sizeinbytes': 2})
2815 
2816     def __delfield_unknown6(self): del self.__field_unknown6
2817 
2818     unknown6=property(__getfield_unknown6, __setfield_unknown6, __delfield_unknown6, None)
2819 
2820     def __getfield_multipartID(self):
2821         return self.__field_multipartID.getvalue()
2822 
2823     def __setfield_multipartID(self, value):
2824         if isinstance(value,UINT):
2825             self.__field_multipartID=value
2826         else:
2827             self.__field_multipartID=UINT(value,**{'sizeinbytes': 2})
2828 
2829     def __delfield_multipartID(self): del self.__field_multipartID
2830 
2831     multipartID=property(__getfield_multipartID, __setfield_multipartID, __delfield_multipartID, None)
2832 
2833     def __getfield_unknown14(self):
2834         return self.__field_unknown14.getvalue()
2835 
2836     def __setfield_unknown14(self, value):
2837         if isinstance(value,UINT):
2838             self.__field_unknown14=value
2839         else:
2840             self.__field_unknown14=UINT(value,**{'sizeinbytes': 2})
2841 
2842     def __delfield_unknown14(self): del self.__field_unknown14
2843 
2844     unknown14=property(__getfield_unknown14, __setfield_unknown14, __delfield_unknown14, None)
2845 
2846     def __getfield_bin_header3(self):
2847         return self.__field_bin_header3.getvalue()
2848 
2849     def __setfield_bin_header3(self, value):
2850         if isinstance(value,UINT):
2851             self.__field_bin_header3=value
2852         else:
2853             self.__field_bin_header3=UINT(value,**{'sizeinbytes': 1})
2854 
2855     def __delfield_bin_header3(self): del self.__field_bin_header3
2856 
2857     bin_header3=property(__getfield_bin_header3, __setfield_bin_header3, __delfield_bin_header3, None)
2858 
2859     def __getfield_num_msg_elements(self):
2860         return self.__field_num_msg_elements.getvalue()
2861 
2862     def __setfield_num_msg_elements(self, value):
2863         if isinstance(value,UINT):
2864             self.__field_num_msg_elements=value
2865         else:
2866             self.__field_num_msg_elements=UINT(value,**{'sizeinbytes': 1})
2867 
2868     def __delfield_num_msg_elements(self): del self.__field_num_msg_elements
2869 
2870     num_msg_elements=property(__getfield_num_msg_elements, __setfield_num_msg_elements, __delfield_num_msg_elements, None)
2871 
2872     def __getfield_msglengths(self):
2873         try: self.__field_msglengths
2874         except:
2875             self.__field_msglengths=LIST(**{'elementclass': _gen_p_lgvx8100_250, 'length': 20})
2876         return self.__field_msglengths.getvalue()
2877 
2878     def __setfield_msglengths(self, value):
2879         if isinstance(value,LIST):
2880             self.__field_msglengths=value
2881         else:
2882             self.__field_msglengths=LIST(value,**{'elementclass': _gen_p_lgvx8100_250, 'length': 20})
2883 
2884     def __delfield_msglengths(self): del self.__field_msglengths
2885 
2886     msglengths=property(__getfield_msglengths, __setfield_msglengths, __delfield_msglengths, None)
2887 
2888     def __getfield_msgs(self):
2889         try: self.__field_msgs
2890         except:
2891             self.__field_msgs=LIST(**{'length': 20, 'elementclass': SMSINBOXMSGFRAGMENT})
2892         return self.__field_msgs.getvalue()
2893 
2894     def __setfield_msgs(self, value):
2895         if isinstance(value,LIST):
2896             self.__field_msgs=value
2897         else:
2898             self.__field_msgs=LIST(value,**{'length': 20, 'elementclass': SMSINBOXMSGFRAGMENT})
2899 
2900     def __delfield_msgs(self): del self.__field_msgs
2901 
2902     msgs=property(__getfield_msgs, __setfield_msgs, __delfield_msgs, None)
2903 
2904     def __getfield_unknown12(self):
2905         return self.__field_unknown12.getvalue()
2906 
2907     def __setfield_unknown12(self, value):
2908         if isinstance(value,DATA):
2909             self.__field_unknown12=value
2910         else:
2911             self.__field_unknown12=DATA(value,**{'sizeinbytes': 60})
2912 
2913     def __delfield_unknown12(self): del self.__field_unknown12
2914 
2915     unknown12=property(__getfield_unknown12, __setfield_unknown12, __delfield_unknown12, None)
2916 
2917     def __getfield_senders_name(self):
2918         return self.__field_senders_name.getvalue()
2919 
2920     def __setfield_senders_name(self, value):
2921         if isinstance(value,USTRING):
2922             self.__field_senders_name=value
2923         else:
2924             self.__field_senders_name=USTRING(value,**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING})
2925 
2926     def __delfield_senders_name(self): del self.__field_senders_name
2927 
2928     senders_name=property(__getfield_senders_name, __setfield_senders_name, __delfield_senders_name, None)
2929 
2930     def __getfield_unknown9(self):
2931         return self.__field_unknown9.getvalue()
2932 
2933     def __setfield_unknown9(self, value):
2934         if isinstance(value,DATA):
2935             self.__field_unknown9=value
2936         else:
2937             self.__field_unknown9=DATA(value,**{'sizeinbytes': 169})
2938 
2939     def __delfield_unknown9(self): del self.__field_unknown9
2940 
2941     unknown9=property(__getfield_unknown9, __setfield_unknown9, __delfield_unknown9, None)
2942 
2943     def iscontainer(self):
2944         return True
2945 
2946     def containerelements(self):
2947         yield ('msg_index1', self.__field_msg_index1, None)
2948         yield ('msg_index2', self.__field_msg_index2, None)
2949         yield ('unknown2', self.__field_unknown2, None)
2950         yield ('timesent', self.__field_timesent, None)
2951         yield ('unknown', self.__field_unknown, None)
2952         yield ('callback_length', self.__field_callback_length, None)
2953         yield ('callback', self.__field_callback, None)
2954         yield ('sender_length', self.__field_sender_length, None)
2955         yield ('sender', self.__field_sender, None)
2956         yield ('unknown3', self.__field_unknown3, None)
2957         yield ('lg_time', self.__field_lg_time, None)
2958         yield ('unknown4', self.__field_unknown4, None)
2959         yield ('GPStime', self.__field_GPStime, None)
2960         yield ('unknown5', self.__field_unknown5, None)
2961         yield ('read', self.__field_read, None)
2962         yield ('locked', self.__field_locked, None)
2963         yield ('unknown8', self.__field_unknown8, None)
2964         yield ('priority', self.__field_priority, None)
2965         yield ('unknown11', self.__field_unknown11, None)
2966         yield ('subject', self.__field_subject, None)
2967         yield ('bin_header1', self.__field_bin_header1, None)
2968         yield ('bin_header2', self.__field_bin_header2, None)
2969         yield ('unknown6', self.__field_unknown6, None)
2970         yield ('multipartID', self.__field_multipartID, None)
2971         yield ('unknown14', self.__field_unknown14, None)
2972         yield ('bin_header3', self.__field_bin_header3, None)
2973         yield ('num_msg_elements', self.__field_num_msg_elements, None)
2974         yield ('msglengths', self.__field_msglengths, None)
2975         yield ('msgs', self.__field_msgs, None)
2976         yield ('unknown12', self.__field_unknown12, None)
2977         yield ('senders_name', self.__field_senders_name, None)
2978         yield ('unknown9', self.__field_unknown9, None)
2979 
2980 
2981 
2982 
2983 class _gen_p_lgvx8100_230(BaseProtogenClass):
2984     'Anonymous inner class'
2985     __fields=['byte']
2986 
2987     def __init__(self, *args, **kwargs):
2988         dict={}
2989         # What was supplied to this function
2990         dict.update(kwargs)
2991         # Parent constructor
2992         super(_gen_p_lgvx8100_230,self).__init__(**dict)
2993         if self.__class__ is _gen_p_lgvx8100_230:
2994             self._update(args,dict)
2995 
2996 
2997     def getfields(self):
2998         return self.__fields
2999 
3000 
3001     def _update(self, args, kwargs):
3002         super(_gen_p_lgvx8100_230,self)._update(args,kwargs)
3003         keys=kwargs.keys()
3004         for key in keys:
3005             if key in self.__fields:
3006                 setattr(self, key, kwargs[key])
3007                 del kwargs[key]
3008         # Were any unrecognized kwargs passed in?
3009         if __debug__:
3010             self._complainaboutunusedargs(_gen_p_lgvx8100_230,kwargs)
3011         if len(args):
3012             dict2={'sizeinbytes': 1}
3013             dict2.update(kwargs)
3014             kwargs=dict2
3015             self.__field_byte=UINT(*args,**dict2)
3016         # Make all P fields that haven't already been constructed
3017 
3018 
3019     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3020         'Writes this packet to the supplied buffer'
3021         self._bufferstartoffset=buf.getcurrentoffset()
3022         self.__field_byte.writetobuffer(buf)
3023         self._bufferendoffset=buf.getcurrentoffset()
3024         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3025 
3026 
3027     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3028         'Reads this packet from the supplied buffer'
3029         self._bufferstartoffset=buf.getcurrentoffset()
3030         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3031         self.__field_byte=UINT(**{'sizeinbytes': 1})
3032         self.__field_byte.readfrombuffer(buf)
3033         self._bufferendoffset=buf.getcurrentoffset()
3034 
3035 
3036     def __getfield_byte(self):
3037         return self.__field_byte.getvalue()
3038 
3039     def __setfield_byte(self, value):
3040         if isinstance(value,UINT):
3041             self.__field_byte=value
3042         else:
3043             self.__field_byte=UINT(value,**{'sizeinbytes': 1})
3044 
3045     def __delfield_byte(self): del self.__field_byte
3046 
3047     byte=property(__getfield_byte, __setfield_byte, __delfield_byte, "individual byte of senders phone number")
3048 
3049     def iscontainer(self):
3050         return True
3051 
3052     def containerelements(self):
3053         yield ('byte', self.__field_byte, "individual byte of senders phone number")
3054 
3055 
3056 
3057 
3058 class _gen_p_lgvx8100_250(BaseProtogenClass):
3059     'Anonymous inner class'
3060     __fields=['msglength']
3061 
3062     def __init__(self, *args, **kwargs):
3063         dict={}
3064         # What was supplied to this function
3065         dict.update(kwargs)
3066         # Parent constructor
3067         super(_gen_p_lgvx8100_250,self).__init__(**dict)
3068         if self.__class__ is _gen_p_lgvx8100_250:
3069             self._update(args,dict)
3070 
3071 
3072     def getfields(self):
3073         return self.__fields
3074 
3075 
3076     def _update(self, args, kwargs):
3077         super(_gen_p_lgvx8100_250,self)._update(args,kwargs)
3078         keys=kwargs.keys()
3079         for key in keys:
3080             if key in self.__fields:
3081                 setattr(self, key, kwargs[key])
3082                 del kwargs[key]
3083         # Were any unrecognized kwargs passed in?
3084         if __debug__:
3085             self._complainaboutunusedargs(_gen_p_lgvx8100_250,kwargs)
3086         if len(args):
3087             dict2={'sizeinbytes': 1}
3088             dict2.update(kwargs)
3089             kwargs=dict2
3090             self.__field_msglength=UINT(*args,**dict2)
3091         # Make all P fields that haven't already been constructed
3092 
3093 
3094     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3095         'Writes this packet to the supplied buffer'
3096         self._bufferstartoffset=buf.getcurrentoffset()
3097         self.__field_msglength.writetobuffer(buf)
3098         self._bufferendoffset=buf.getcurrentoffset()
3099         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3100 
3101 
3102     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3103         'Reads this packet from the supplied buffer'
3104         self._bufferstartoffset=buf.getcurrentoffset()
3105         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3106         self.__field_msglength=UINT(**{'sizeinbytes': 1})
3107         self.__field_msglength.readfrombuffer(buf)
3108         self._bufferendoffset=buf.getcurrentoffset()
3109 
3110 
3111     def __getfield_msglength(self):
3112         return self.__field_msglength.getvalue()
3113 
3114     def __setfield_msglength(self, value):
3115         if isinstance(value,UINT):
3116             self.__field_msglength=value
3117         else:
3118             self.__field_msglength=UINT(value,**{'sizeinbytes': 1})
3119 
3120     def __delfield_msglength(self): del self.__field_msglength
3121 
3122     msglength=property(__getfield_msglength, __setfield_msglength, __delfield_msglength, "lengths of individual messages in septets")
3123 
3124     def iscontainer(self):
3125         return True
3126 
3127     def containerelements(self):
3128         yield ('msglength', self.__field_msglength, "lengths of individual messages in septets")
3129 
3130 
3131 
3132 
3133 class sms_quick_text(BaseProtogenClass):
3134     __fields=['msgs']
3135 
3136     def __init__(self, *args, **kwargs):
3137         dict={}
3138         # What was supplied to this function
3139         dict.update(kwargs)
3140         # Parent constructor
3141         super(sms_quick_text,self).__init__(**dict)
3142         if self.__class__ is sms_quick_text:
3143             self._update(args,dict)
3144 
3145 
3146     def getfields(self):
3147         return self.__fields
3148 
3149 
3150     def _update(self, args, kwargs):
3151         super(sms_quick_text,self)._update(args,kwargs)
3152         keys=kwargs.keys()
3153         for key in keys:
3154             if key in self.__fields:
3155                 setattr(self, key, kwargs[key])
3156                 del kwargs[key]
3157         # Were any unrecognized kwargs passed in?
3158         if __debug__:
3159             self._complainaboutunusedargs(sms_quick_text,kwargs)
3160         if len(args):
3161             dict2={'elementclass': _gen_p_lgvx8100_264, 'length': SMS_CANNED_MAX_ITEMS, 'createdefault': True}
3162             dict2.update(kwargs)
3163             kwargs=dict2
3164             self.__field_msgs=LIST(*args,**dict2)
3165         # Make all P fields that haven't already been constructed
3166 
3167 
3168     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3169         'Writes this packet to the supplied buffer'
3170         self._bufferstartoffset=buf.getcurrentoffset()
3171         try: self.__field_msgs
3172         except:
3173             self.__field_msgs=LIST(**{'elementclass': _gen_p_lgvx8100_264, 'length': SMS_CANNED_MAX_ITEMS, 'createdefault': True})
3174         self.__field_msgs.writetobuffer(buf)
3175         self._bufferendoffset=buf.getcurrentoffset()
3176         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3177 
3178 
3179     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3180         'Reads this packet from the supplied buffer'
3181         self._bufferstartoffset=buf.getcurrentoffset()
3182         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3183         self.__field_msgs=LIST(**{'elementclass': _gen_p_lgvx8100_264, 'length': SMS_CANNED_MAX_ITEMS, 'createdefault': True})
3184         self.__field_msgs.readfrombuffer(buf)
3185         self._bufferendoffset=buf.getcurrentoffset()
3186 
3187 
3188     def __getfield_msgs(self):
3189         try: self.__field_msgs
3190         except:
3191             self.__field_msgs=LIST(**{'elementclass': _gen_p_lgvx8100_264, 'length': SMS_CANNED_MAX_ITEMS, 'createdefault': True})
3192         return self.__field_msgs.getvalue()
3193 
3194     def __setfield_msgs(self, value):
3195         if isinstance(value,LIST):
3196             self.__field_msgs=value
3197         else:
3198             self.__field_msgs=LIST(value,**{'elementclass': _gen_p_lgvx8100_264, 'length': SMS_CANNED_MAX_ITEMS, 'createdefault': True})
3199 
3200     def __delfield_msgs(self): del self.__field_msgs
3201 
3202     msgs=property(__getfield_msgs, __setfield_msgs, __delfield_msgs, None)
3203 
3204     def iscontainer(self):
3205         return True
3206 
3207     def containerelements(self):
3208         yield ('msgs', self.__field_msgs, None)
3209 
3210 
3211 
3212 
3213 class _gen_p_lgvx8100_264(BaseProtogenClass):
3214     'Anonymous inner class'
3215     __fields=['msg']
3216 
3217     def __init__(self, *args, **kwargs):
3218         dict={}
3219         # What was supplied to this function
3220         dict.update(kwargs)
3221         # Parent constructor
3222         super(_gen_p_lgvx8100_264,self).__init__(**dict)
3223         if self.__class__ is _gen_p_lgvx8100_264:
3224             self._update(args,dict)
3225 
3226 
3227     def getfields(self):
3228         return self.__fields
3229 
3230 
3231     def _update(self, args, kwargs):
3232         super(_gen_p_lgvx8100_264,self)._update(args,kwargs)
3233         keys=kwargs.keys()
3234         for key in keys:
3235             if key in self.__fields:
3236                 setattr(self, key, kwargs[key])
3237                 del kwargs[key]
3238         # Were any unrecognized kwargs passed in?
3239         if __debug__:
3240             self._complainaboutunusedargs(_gen_p_lgvx8100_264,kwargs)
3241         if len(args):
3242             dict2={'sizeinbytes': 101, 'encoding': PHONE_ENCODING, 'default': ""}
3243             dict2.update(kwargs)
3244             kwargs=dict2
3245             self.__field_msg=USTRING(*args,**dict2)
3246         # Make all P fields that haven't already been constructed
3247 
3248 
3249     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3250         'Writes this packet to the supplied buffer'
3251         self._bufferstartoffset=buf.getcurrentoffset()
3252         try: self.__field_msg
3253         except:
3254             self.__field_msg=USTRING(**{'sizeinbytes': 101, 'encoding': PHONE_ENCODING, 'default': ""})
3255         self.__field_msg.writetobuffer(buf)
3256         self._bufferendoffset=buf.getcurrentoffset()
3257         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3258 
3259 
3260     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3261         'Reads this packet from the supplied buffer'
3262         self._bufferstartoffset=buf.getcurrentoffset()
3263         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3264         self.__field_msg=USTRING(**{'sizeinbytes': 101, 'encoding': PHONE_ENCODING, 'default': ""})
3265         self.__field_msg.readfrombuffer(buf)
3266         self._bufferendoffset=buf.getcurrentoffset()
3267 
3268 
3269     def __getfield_msg(self):
3270         try: self.__field_msg
3271         except:
3272             self.__field_msg=USTRING(**{'sizeinbytes': 101, 'encoding': PHONE_ENCODING, 'default': ""})
3273         return self.__field_msg.getvalue()
3274 
3275     def __setfield_msg(self, value):
3276         if isinstance(value,USTRING):
3277             self.__field_msg=value
3278         else:
3279             self.__field_msg=USTRING(value,**{'sizeinbytes': 101, 'encoding': PHONE_ENCODING, 'default': ""})
3280 
3281     def __delfield_msg(self): del self.__field_msg
3282 
3283     msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None)
3284 
3285     def iscontainer(self):
3286         return True
3287 
3288     def containerelements(self):
3289         yield ('msg', self.__field_msg, None)
3290 
3291 
3292 
3293 
3294 class textmemo(BaseProtogenClass):
3295     __fields=['text', 'memotime']
3296 
3297     def __init__(self, *args, **kwargs):
3298         dict={}
3299         # What was supplied to this function
3300         dict.update(kwargs)
3301         # Parent constructor
3302         super(textmemo,self).__init__(**dict)
3303         if self.__class__ is textmemo:
3304             self._update(args,dict)
3305 
3306 
3307     def getfields(self):
3308         return self.__fields
3309 
3310 
3311     def _update(self, args, kwargs):
3312         super(textmemo,self)._update(args,kwargs)
3313         keys=kwargs.keys()
3314         for key in keys:
3315             if key in self.__fields:
3316                 setattr(self, key, kwargs[key])
3317                 del kwargs[key]
3318         # Were any unrecognized kwargs passed in?
3319         if __debug__:
3320             self._complainaboutunusedargs(textmemo,kwargs)
3321         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3322         # Make all P fields that haven't already been constructed
3323 
3324 
3325     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3326         'Writes this packet to the supplied buffer'
3327         self._bufferstartoffset=buf.getcurrentoffset()
3328         self.__field_text.writetobuffer(buf)
3329         self.__field_memotime.writetobuffer(buf)
3330         self._bufferendoffset=buf.getcurrentoffset()
3331         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3332 
3333 
3334     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3335         'Reads this packet from the supplied buffer'
3336         self._bufferstartoffset=buf.getcurrentoffset()
3337         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3338         self.__field_text=USTRING(**{'sizeinbytes': 151,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False })
3339         self.__field_text.readfrombuffer(buf)
3340         self.__field_memotime=LGCALDATE(**{'sizeinbytes': 4})
3341         self.__field_memotime.readfrombuffer(buf)
3342         self._bufferendoffset=buf.getcurrentoffset()
3343 
3344 
3345     def __getfield_text(self):
3346         return self.__field_text.getvalue()
3347 
3348     def __setfield_text(self, value):
3349         if isinstance(value,USTRING):
3350             self.__field_text=value
3351         else:
3352             self.__field_text=USTRING(value,**{'sizeinbytes': 151,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False })
3353 
3354     def __delfield_text(self): del self.__field_text
3355 
3356     text=property(__getfield_text, __setfield_text, __delfield_text, None)
3357 
3358     def __getfield_memotime(self):
3359         return self.__field_memotime.getvalue()
3360 
3361     def __setfield_memotime(self, value):
3362         if isinstance(value,LGCALDATE):
3363             self.__field_memotime=value
3364         else:
3365             self.__field_memotime=LGCALDATE(value,**{'sizeinbytes': 4})
3366 
3367     def __delfield_memotime(self): del self.__field_memotime
3368 
3369     memotime=property(__getfield_memotime, __setfield_memotime, __delfield_memotime, None)
3370 
3371     def iscontainer(self):
3372         return True
3373 
3374     def containerelements(self):
3375         yield ('text', self.__field_text, None)
3376         yield ('memotime', self.__field_memotime, None)
3377 
3378 
3379 
3380 
3381 class textmemofile(BaseProtogenClass):
3382     __fields=['itemcount', 'items']
3383 
3384     def __init__(self, *args, **kwargs):
3385         dict={}
3386         # What was supplied to this function
3387         dict.update(kwargs)
3388         # Parent constructor
3389         super(textmemofile,self).__init__(**dict)
3390         if self.__class__ is textmemofile:
3391             self._update(args,dict)
3392 
3393 
3394     def getfields(self):
3395         return self.__fields
3396 
3397 
3398     def _update(self, args, kwargs):
3399         super(textmemofile,self)._update(args,kwargs)
3400         keys=kwargs.keys()
3401         for key in keys:
3402             if key in self.__fields:
3403                 setattr(self, key, kwargs[key])
3404                 del kwargs[key]
3405         # Were any unrecognized kwargs passed in?
3406         if __debug__:
3407             self._complainaboutunusedargs(textmemofile,kwargs)
3408         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3409         # Make all P fields that haven't already been constructed
3410 
3411 
3412     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3413         'Writes this packet to the supplied buffer'
3414         self._bufferstartoffset=buf.getcurrentoffset()
3415         self.__field_itemcount.writetobuffer(buf)
3416         try: self.__field_items
3417         except:
3418             self.__field_items=LIST(**{ 'elementclass': textmemo })
3419         self.__field_items.writetobuffer(buf)
3420         self._bufferendoffset=buf.getcurrentoffset()
3421         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3422 
3423 
3424     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3425         'Reads this packet from the supplied buffer'
3426         self._bufferstartoffset=buf.getcurrentoffset()
3427         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3428         self.__field_itemcount=UINT(**{'sizeinbytes': 4})
3429         self.__field_itemcount.readfrombuffer(buf)
3430         self.__field_items=LIST(**{ 'elementclass': textmemo })
3431         self.__field_items.readfrombuffer(buf)
3432         self._bufferendoffset=buf.getcurrentoffset()
3433 
3434 
3435     def __getfield_itemcount(self):
3436         return self.__field_itemcount.getvalue()
3437 
3438     def __setfield_itemcount(self, value):
3439         if isinstance(value,UINT):
3440             self.__field_itemcount=value
3441         else:
3442             self.__field_itemcount=UINT(value,**{'sizeinbytes': 4})
3443 
3444     def __delfield_itemcount(self): del self.__field_itemcount
3445 
3446     itemcount=property(__getfield_itemcount, __setfield_itemcount, __delfield_itemcount, None)
3447 
3448     def __getfield_items(self):
3449         try: self.__field_items
3450         except:
3451             self.__field_items=LIST(**{ 'elementclass': textmemo })
3452         return self.__field_items.getvalue()
3453 
3454     def __setfield_items(self, value):
3455         if isinstance(value,LIST):
3456             self.__field_items=value
3457         else:
3458             self.__field_items=LIST(value,**{ 'elementclass': textmemo })
3459 
3460     def __delfield_items(self): del self.__field_items
3461 
3462     items=property(__getfield_items, __setfield_items, __delfield_items, None)
3463 
3464     def iscontainer(self):
3465         return True
3466 
3467     def containerelements(self):
3468         yield ('itemcount', self.__field_itemcount, None)
3469         yield ('items', self.__field_items, None)
3470 
3471 
3472 
3473 
3474 class firmwareresponse(BaseProtogenClass):
3475     __fields=['command', 'date1', 'time1', 'date2', 'time2', 'firmware']
3476 
3477     def __init__(self, *args, **kwargs):
3478         dict={}
3479         # What was supplied to this function
3480         dict.update(kwargs)
3481         # Parent constructor
3482         super(firmwareresponse,self).__init__(**dict)
3483         if self.__class__ is firmwareresponse:
3484             self._update(args,dict)
3485 
3486 
3487     def getfields(self):
3488         return self.__fields
3489 
3490 
3491     def _update(self, args, kwargs):
3492         super(firmwareresponse,self)._update(args,kwargs)
3493         keys=kwargs.keys()
3494         for key in keys:
3495             if key in self.__fields:
3496                 setattr(self, key, kwargs[key])
3497                 del kwargs[key]
3498         # Were any unrecognized kwargs passed in?
3499         if __debug__:
3500             self._complainaboutunusedargs(firmwareresponse,kwargs)
3501         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3502         # Make all P fields that haven't already been constructed
3503 
3504 
3505     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3506         'Writes this packet to the supplied buffer'
3507         self._bufferstartoffset=buf.getcurrentoffset()
3508         self.__field_command.writetobuffer(buf)
3509         self.__field_date1.writetobuffer(buf)
3510         self.__field_time1.writetobuffer(buf)
3511         self.__field_date2.writetobuffer(buf)
3512         self.__field_time2.writetobuffer(buf)
3513         self.__field_firmware.writetobuffer(buf)
3514         self._bufferendoffset=buf.getcurrentoffset()
3515         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3516 
3517 
3518     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3519         'Reads this packet from the supplied buffer'
3520         self._bufferstartoffset=buf.getcurrentoffset()
3521         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3522         self.__field_command=UINT(**{'sizeinbytes': 1})
3523         self.__field_command.readfrombuffer(buf)
3524         self.__field_date1=USTRING(**{'sizeinbytes': 11, 'terminator': None})
3525         self.__field_date1.readfrombuffer(buf)
3526         self.__field_time1=USTRING(**{'sizeinbytes': 8, 'terminator': None})
3527         self.__field_time1.readfrombuffer(buf)
3528         self.__field_date2=USTRING(**{'sizeinbytes': 11, 'terminator': None})
3529         self.__field_date2.readfrombuffer(buf)
3530         self.__field_time2=USTRING(**{'sizeinbytes': 8, 'terminator': None})
3531         self.__field_time2.readfrombuffer(buf)
3532         self.__field_firmware=USTRING(**{'sizeinbytes': 8, 'terminator': None})
3533         self.__field_firmware.readfrombuffer(buf)
3534         self._bufferendoffset=buf.getcurrentoffset()
3535 
3536 
3537     def __getfield_command(self):
3538         return self.__field_command.getvalue()
3539 
3540     def __setfield_command(self, value):
3541         if isinstance(value,UINT):
3542             self.__field_command=value
3543         else:
3544             self.__field_command=UINT(value,**{'sizeinbytes': 1})
3545 
3546     def __delfield_command(self): del self.__field_command
3547 
3548     command=property(__getfield_command, __setfield_command, __delfield_command, None)
3549 
3550     def __getfield_date1(self):
3551         return self.__field_date1.getvalue()
3552 
3553     def __setfield_date1(self, value):
3554         if isinstance(value,USTRING):
3555             self.__field_date1=value
3556         else:
3557             self.__field_date1=USTRING(value,**{'sizeinbytes': 11, 'terminator': None})
3558 
3559     def __delfield_date1(self): del self.__field_date1
3560 
3561     date1=property(__getfield_date1, __setfield_date1, __delfield_date1, None)
3562 
3563     def __getfield_time1(self):
3564         return self.__field_time1.getvalue()
3565 
3566     def __setfield_time1(self, value):
3567         if isinstance(value,USTRING):
3568             self.__field_time1=value
3569         else:
3570             self.__field_time1=USTRING(value,**{'sizeinbytes': 8, 'terminator': None})
3571 
3572     def __delfield_time1(self): del self.__field_time1
3573 
3574     time1=property(__getfield_time1, __setfield_time1, __delfield_time1, None)
3575 
3576     def __getfield_date2(self):
3577         return self.__field_date2.getvalue()
3578 
3579     def __setfield_date2(self, value):
3580         if isinstance(value,USTRING):
3581             self.__field_date2=value
3582         else:
3583             self.__field_date2=USTRING(value,**{'sizeinbytes': 11, 'terminator': None})
3584 
3585     def __delfield_date2(self): del self.__field_date2
3586 
3587     date2=property(__getfield_date2, __setfield_date2, __delfield_date2, None)
3588 
3589     def __getfield_time2(self):
3590         return self.__field_time2.getvalue()
3591 
3592     def __setfield_time2(self, value):
3593         if isinstance(value,USTRING):
3594             self.__field_time2=value
3595         else:
3596             self.__field_time2=USTRING(value,**{'sizeinbytes': 8, 'terminator': None})
3597 
3598     def __delfield_time2(self): del self.__field_time2
3599 
3600     time2=property(__getfield_time2, __setfield_time2, __delfield_time2, None)
3601 
3602     def __getfield_firmware(self):
3603         return self.__field_firmware.getvalue()
3604 
3605     def __setfield_firmware(self, value):
3606         if isinstance(value,USTRING):
3607             self.__field_firmware=value
3608         else:
3609             self.__field_firmware=USTRING(value,**{'sizeinbytes': 8, 'terminator': None})
3610 
3611     def __delfield_firmware(self): del self.__field_firmware
3612 
3613     firmware=property(__getfield_firmware, __setfield_firmware, __delfield_firmware, None)
3614 
3615     def iscontainer(self):
3616         return True
3617 
3618     def containerelements(self):
3619         yield ('command', self.__field_command, None)
3620         yield ('date1', self.__field_date1, None)
3621         yield ('time1', self.__field_time1, None)
3622         yield ('date2', self.__field_date2, None)
3623         yield ('time2', self.__field_time2, None)
3624         yield ('firmware', self.__field_firmware, None)
3625 
3626 
3627 
3628 
3629