PyXR

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



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

Generated by PyXR 0.9.4