PyXR

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

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