PyXR

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

0001 # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE
0002 
0003 """Various descriptions of data specific to LG VX5200"""
0004 
0005 from common import PhoneBookBusyException
0006 
0007 from prototypes import *
0008 
0009 # Make all lg stuff available in this module as well
0010 from p_lg import *
0011 
0012 # we are the same as lgvx8100 except as noted
0013 # below
0014 from p_lgvx8100 import *
0015 
0016 # We use LSB for all integer like fields
0017 UINT=UINTlsb
0018 BOOL=BOOLlsb
0019 
0020 BREW_FILE_SYSTEM=0
0021 
0022 PHONE_ENCODING='iso8859_1'
0023 
0024 # need to call stat to get the file time/data
0025 broken_filelist_date=True
0026 class indexentry(BaseProtogenClass):
0027     __fields=['index', 'type', 'filename', 'icon', 'date', 'dunno']
0028 
0029     def __init__(self, *args, **kwargs):
0030         dict={}
0031         # What was supplied to this function
0032         dict.update(kwargs)
0033         # Parent constructor
0034         super(indexentry,self).__init__(**dict)
0035         if self.__class__ is indexentry:
0036             self._update(args,dict)
0037 
0038 
0039     def getfields(self):
0040         return self.__fields
0041 
0042 
0043     def _update(self, args, kwargs):
0044         super(indexentry,self)._update(args,kwargs)
0045         keys=kwargs.keys()
0046         for key in keys:
0047             if key in self.__fields:
0048                 setattr(self, key, kwargs[key])
0049                 del kwargs[key]
0050         # Were any unrecognized kwargs passed in?
0051         if __debug__:
0052             self._complainaboutunusedargs(indexentry,kwargs)
0053         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0054         # Make all P fields that haven't already been constructed
0055 
0056 
0057     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0058         'Writes this packet to the supplied buffer'
0059         self._bufferstartoffset=buf.getcurrentoffset()
0060         self.__field_index.writetobuffer(buf)
0061         self.__field_type.writetobuffer(buf)
0062         self.__field_filename.writetobuffer(buf)
0063         try: self.__field_icon
0064         except:
0065             self.__field_icon=UINT(**{'sizeinbytes': 4, 'default':0})
0066         self.__field_icon.writetobuffer(buf)
0067         try: self.__field_date
0068         except:
0069             self.__field_date=UINT(**{'sizeinbytes': 4, 'default': 0})
0070         self.__field_date.writetobuffer(buf)
0071         self.__field_dunno.writetobuffer(buf)
0072         self._bufferendoffset=buf.getcurrentoffset()
0073         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0074 
0075 
0076     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0077         'Reads this packet from the supplied buffer'
0078         self._bufferstartoffset=buf.getcurrentoffset()
0079         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0080         self.__field_index=UINT(**{'sizeinbytes': 2})
0081         self.__field_index.readfrombuffer(buf)
0082         self.__field_type=UINT(**{'sizeinbytes': 2})
0083         self.__field_type.readfrombuffer(buf)
0084         self.__field_filename=USTRING(**{'sizeinbytes': 60, 'raiseonunterminatedread': False, 'raiseontruncate': False })
0085         self.__field_filename.readfrombuffer(buf)
0086         self.__field_icon=UINT(**{'sizeinbytes': 4, 'default':0})
0087         self.__field_icon.readfrombuffer(buf)
0088         self.__field_date=UINT(**{'sizeinbytes': 4, 'default': 0})
0089         self.__field_date.readfrombuffer(buf)
0090         self.__field_dunno=UINT(**{'sizeinbytes': 4})
0091         self.__field_dunno.readfrombuffer(buf)
0092         self._bufferendoffset=buf.getcurrentoffset()
0093 
0094 
0095     def __getfield_index(self):
0096         return self.__field_index.getvalue()
0097 
0098     def __setfield_index(self, value):
0099         if isinstance(value,UINT):
0100             self.__field_index=value
0101         else:
0102             self.__field_index=UINT(value,**{'sizeinbytes': 2})
0103 
0104     def __delfield_index(self): del self.__field_index
0105 
0106     index=property(__getfield_index, __setfield_index, __delfield_index, None)
0107 
0108     def __getfield_type(self):
0109         return self.__field_type.getvalue()
0110 
0111     def __setfield_type(self, value):
0112         if isinstance(value,UINT):
0113             self.__field_type=value
0114         else:
0115             self.__field_type=UINT(value,**{'sizeinbytes': 2})
0116 
0117     def __delfield_type(self): del self.__field_type
0118 
0119     type=property(__getfield_type, __setfield_type, __delfield_type, None)
0120 
0121     def __getfield_filename(self):
0122         return self.__field_filename.getvalue()
0123 
0124     def __setfield_filename(self, value):
0125         if isinstance(value,USTRING):
0126             self.__field_filename=value
0127         else:
0128             self.__field_filename=USTRING(value,**{'sizeinbytes': 60, 'raiseonunterminatedread': False, 'raiseontruncate': False })
0129 
0130     def __delfield_filename(self): del self.__field_filename
0131 
0132     filename=property(__getfield_filename, __setfield_filename, __delfield_filename, "includes full pathname")
0133 
0134     def __getfield_icon(self):
0135         try: self.__field_icon
0136         except:
0137             self.__field_icon=UINT(**{'sizeinbytes': 4, 'default':0})
0138         return self.__field_icon.getvalue()
0139 
0140     def __setfield_icon(self, value):
0141         if isinstance(value,UINT):
0142             self.__field_icon=value
0143         else:
0144             self.__field_icon=UINT(value,**{'sizeinbytes': 4, 'default':0})
0145 
0146     def __delfield_icon(self): del self.__field_icon
0147 
0148     icon=property(__getfield_icon, __setfield_icon, __delfield_icon, None)
0149 
0150     def __getfield_date(self):
0151         try: self.__field_date
0152         except:
0153             self.__field_date=UINT(**{'sizeinbytes': 4, 'default': 0})
0154         return self.__field_date.getvalue()
0155 
0156     def __setfield_date(self, value):
0157         if isinstance(value,UINT):
0158             self.__field_date=value
0159         else:
0160             self.__field_date=UINT(value,**{'sizeinbytes': 4, 'default': 0})
0161 
0162     def __delfield_date(self): del self.__field_date
0163 
0164     date=property(__getfield_date, __setfield_date, __delfield_date, "i think this is bitfield of the date")
0165 
0166     def __getfield_dunno(self):
0167         return self.__field_dunno.getvalue()
0168 
0169     def __setfield_dunno(self, value):
0170         if isinstance(value,UINT):
0171             self.__field_dunno=value
0172         else:
0173             self.__field_dunno=UINT(value,**{'sizeinbytes': 4})
0174 
0175     def __delfield_dunno(self): del self.__field_dunno
0176 
0177     dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, None)
0178 
0179     def iscontainer(self):
0180         return True
0181 
0182     def containerelements(self):
0183         yield ('index', self.__field_index, None)
0184         yield ('type', self.__field_type, None)
0185         yield ('filename', self.__field_filename, "includes full pathname")
0186         yield ('icon', self.__field_icon, None)
0187         yield ('date', self.__field_date, "i think this is bitfield of the date")
0188         yield ('dunno', self.__field_dunno, None)
0189 
0190 
0191 
0192 
0193 class indexfile(BaseProtogenClass):
0194     "Used for tracking wallpaper and ringtones"
0195     __fields=['items']
0196 
0197     def __init__(self, *args, **kwargs):
0198         dict={}
0199         # What was supplied to this function
0200         dict.update(kwargs)
0201         # Parent constructor
0202         super(indexfile,self).__init__(**dict)
0203         if self.__class__ is indexfile:
0204             self._update(args,dict)
0205 
0206 
0207     def getfields(self):
0208         return self.__fields
0209 
0210 
0211     def _update(self, args, kwargs):
0212         super(indexfile,self)._update(args,kwargs)
0213         keys=kwargs.keys()
0214         for key in keys:
0215             if key in self.__fields:
0216                 setattr(self, key, kwargs[key])
0217                 del kwargs[key]
0218         # Were any unrecognized kwargs passed in?
0219         if __debug__:
0220             self._complainaboutunusedargs(indexfile,kwargs)
0221         if len(args):
0222             dict2={'elementclass': indexentry, 'createdefault': True}
0223             dict2.update(kwargs)
0224             kwargs=dict2
0225             self.__field_items=LIST(*args,**dict2)
0226         # Make all P fields that haven't already been constructed
0227 
0228 
0229     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0230         'Writes this packet to the supplied buffer'
0231         self._bufferstartoffset=buf.getcurrentoffset()
0232         try: self.__field_items
0233         except:
0234             self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True})
0235         self.__field_items.writetobuffer(buf)
0236         self._bufferendoffset=buf.getcurrentoffset()
0237         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0238 
0239 
0240     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0241         'Reads this packet from the supplied buffer'
0242         self._bufferstartoffset=buf.getcurrentoffset()
0243         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0244         self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True})
0245         self.__field_items.readfrombuffer(buf)
0246         self._bufferendoffset=buf.getcurrentoffset()
0247 
0248 
0249     def __getfield_items(self):
0250         try: self.__field_items
0251         except:
0252             self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True})
0253         return self.__field_items.getvalue()
0254 
0255     def __setfield_items(self, value):
0256         if isinstance(value,LIST):
0257             self.__field_items=value
0258         else:
0259             self.__field_items=LIST(value,**{'elementclass': indexentry, 'createdefault': True})
0260 
0261     def __delfield_items(self): del self.__field_items
0262 
0263     items=property(__getfield_items, __setfield_items, __delfield_items, None)
0264 
0265     def iscontainer(self):
0266         return True
0267 
0268     def containerelements(self):
0269         yield ('items', self.__field_items, None)
0270 
0271 
0272 
0273 
0274 class msg_record(BaseProtogenClass):
0275     __fields=['unknown1', 'binary', 'unknown3', 'unknown4', 'unknown6', 'length', 'msg']
0276 
0277     def __init__(self, *args, **kwargs):
0278         dict={}
0279         # What was supplied to this function
0280         dict.update(kwargs)
0281         # Parent constructor
0282         super(msg_record,self).__init__(**dict)
0283         if self.__class__ is msg_record:
0284             self._update(args,dict)
0285 
0286 
0287     def getfields(self):
0288         return self.__fields
0289 
0290 
0291     def _update(self, args, kwargs):
0292         super(msg_record,self)._update(args,kwargs)
0293         keys=kwargs.keys()
0294         for key in keys:
0295             if key in self.__fields:
0296                 setattr(self, key, kwargs[key])
0297                 del kwargs[key]
0298         # Were any unrecognized kwargs passed in?
0299         if __debug__:
0300             self._complainaboutunusedargs(msg_record,kwargs)
0301         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0302         # Make all P fields that haven't already been constructed
0303 
0304 
0305     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0306         'Writes this packet to the supplied buffer'
0307         self._bufferstartoffset=buf.getcurrentoffset()
0308         self.__field_unknown1.writetobuffer(buf)
0309         self.__field_binary.writetobuffer(buf)
0310         self.__field_unknown3.writetobuffer(buf)
0311         self.__field_unknown4.writetobuffer(buf)
0312         self.__field_unknown6.writetobuffer(buf)
0313         self.__field_length.writetobuffer(buf)
0314         try: self.__field_msg
0315         except:
0316             self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx5200_89, 'length': 219})
0317         self.__field_msg.writetobuffer(buf)
0318         self._bufferendoffset=buf.getcurrentoffset()
0319         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0320 
0321 
0322     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0323         'Reads this packet from the supplied buffer'
0324         self._bufferstartoffset=buf.getcurrentoffset()
0325         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0326         self.__field_unknown1=UINT(**{'sizeinbytes': 1})
0327         self.__field_unknown1.readfrombuffer(buf)
0328         self.__field_binary=UINT(**{'sizeinbytes': 1})
0329         self.__field_binary.readfrombuffer(buf)
0330         self.__field_unknown3=UINT(**{'sizeinbytes': 1})
0331         self.__field_unknown3.readfrombuffer(buf)
0332         self.__field_unknown4=UINT(**{'sizeinbytes': 1})
0333         self.__field_unknown4.readfrombuffer(buf)
0334         self.__field_unknown6=UINT(**{'sizeinbytes': 1})
0335         self.__field_unknown6.readfrombuffer(buf)
0336         self.__field_length=UINT(**{'sizeinbytes': 1})
0337         self.__field_length.readfrombuffer(buf)
0338         self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx5200_89, 'length': 219})
0339         self.__field_msg.readfrombuffer(buf)
0340         self._bufferendoffset=buf.getcurrentoffset()
0341 
0342 
0343     def __getfield_unknown1(self):
0344         return self.__field_unknown1.getvalue()
0345 
0346     def __setfield_unknown1(self, value):
0347         if isinstance(value,UINT):
0348             self.__field_unknown1=value
0349         else:
0350             self.__field_unknown1=UINT(value,**{'sizeinbytes': 1})
0351 
0352     def __delfield_unknown1(self): del self.__field_unknown1
0353 
0354     unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None)
0355 
0356     def __getfield_binary(self):
0357         return self.__field_binary.getvalue()
0358 
0359     def __setfield_binary(self, value):
0360         if isinstance(value,UINT):
0361             self.__field_binary=value
0362         else:
0363             self.__field_binary=UINT(value,**{'sizeinbytes': 1})
0364 
0365     def __delfield_binary(self): del self.__field_binary
0366 
0367     binary=property(__getfield_binary, __setfield_binary, __delfield_binary, None)
0368 
0369     def __getfield_unknown3(self):
0370         return self.__field_unknown3.getvalue()
0371 
0372     def __setfield_unknown3(self, value):
0373         if isinstance(value,UINT):
0374             self.__field_unknown3=value
0375         else:
0376             self.__field_unknown3=UINT(value,**{'sizeinbytes': 1})
0377 
0378     def __delfield_unknown3(self): del self.__field_unknown3
0379 
0380     unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None)
0381 
0382     def __getfield_unknown4(self):
0383         return self.__field_unknown4.getvalue()
0384 
0385     def __setfield_unknown4(self, value):
0386         if isinstance(value,UINT):
0387             self.__field_unknown4=value
0388         else:
0389             self.__field_unknown4=UINT(value,**{'sizeinbytes': 1})
0390 
0391     def __delfield_unknown4(self): del self.__field_unknown4
0392 
0393     unknown4=property(__getfield_unknown4, __setfield_unknown4, __delfield_unknown4, None)
0394 
0395     def __getfield_unknown6(self):
0396         return self.__field_unknown6.getvalue()
0397 
0398     def __setfield_unknown6(self, value):
0399         if isinstance(value,UINT):
0400             self.__field_unknown6=value
0401         else:
0402             self.__field_unknown6=UINT(value,**{'sizeinbytes': 1})
0403 
0404     def __delfield_unknown6(self): del self.__field_unknown6
0405 
0406     unknown6=property(__getfield_unknown6, __setfield_unknown6, __delfield_unknown6, None)
0407 
0408     def __getfield_length(self):
0409         return self.__field_length.getvalue()
0410 
0411     def __setfield_length(self, value):
0412         if isinstance(value,UINT):
0413             self.__field_length=value
0414         else:
0415             self.__field_length=UINT(value,**{'sizeinbytes': 1})
0416 
0417     def __delfield_length(self): del self.__field_length
0418 
0419     length=property(__getfield_length, __setfield_length, __delfield_length, None)
0420 
0421     def __getfield_msg(self):
0422         try: self.__field_msg
0423         except:
0424             self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx5200_89, 'length': 219})
0425         return self.__field_msg.getvalue()
0426 
0427     def __setfield_msg(self, value):
0428         if isinstance(value,LIST):
0429             self.__field_msg=value
0430         else:
0431             self.__field_msg=LIST(value,**{'elementclass': _gen_p_lgvx5200_89, 'length': 219})
0432 
0433     def __delfield_msg(self): del self.__field_msg
0434 
0435     msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None)
0436 
0437     def iscontainer(self):
0438         return True
0439 
0440     def containerelements(self):
0441         yield ('unknown1', self.__field_unknown1, None)
0442         yield ('binary', self.__field_binary, None)
0443         yield ('unknown3', self.__field_unknown3, None)
0444         yield ('unknown4', self.__field_unknown4, None)
0445         yield ('unknown6', self.__field_unknown6, None)
0446         yield ('length', self.__field_length, None)
0447         yield ('msg', self.__field_msg, None)
0448 
0449 
0450 
0451 
0452 class _gen_p_lgvx5200_89(BaseProtogenClass):
0453     'Anonymous inner class'
0454     __fields=['byte']
0455 
0456     def __init__(self, *args, **kwargs):
0457         dict={}
0458         # What was supplied to this function
0459         dict.update(kwargs)
0460         # Parent constructor
0461         super(_gen_p_lgvx5200_89,self).__init__(**dict)
0462         if self.__class__ is _gen_p_lgvx5200_89:
0463             self._update(args,dict)
0464 
0465 
0466     def getfields(self):
0467         return self.__fields
0468 
0469 
0470     def _update(self, args, kwargs):
0471         super(_gen_p_lgvx5200_89,self)._update(args,kwargs)
0472         keys=kwargs.keys()
0473         for key in keys:
0474             if key in self.__fields:
0475                 setattr(self, key, kwargs[key])
0476                 del kwargs[key]
0477         # Were any unrecognized kwargs passed in?
0478         if __debug__:
0479             self._complainaboutunusedargs(_gen_p_lgvx5200_89,kwargs)
0480         if len(args):
0481             dict2={'sizeinbytes': 1}
0482             dict2.update(kwargs)
0483             kwargs=dict2
0484             self.__field_byte=UINT(*args,**dict2)
0485         # Make all P fields that haven't already been constructed
0486 
0487 
0488     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0489         'Writes this packet to the supplied buffer'
0490         self._bufferstartoffset=buf.getcurrentoffset()
0491         self.__field_byte.writetobuffer(buf)
0492         self._bufferendoffset=buf.getcurrentoffset()
0493         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0494 
0495 
0496     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0497         'Reads this packet from the supplied buffer'
0498         self._bufferstartoffset=buf.getcurrentoffset()
0499         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0500         self.__field_byte=UINT(**{'sizeinbytes': 1})
0501         self.__field_byte.readfrombuffer(buf)
0502         self._bufferendoffset=buf.getcurrentoffset()
0503 
0504 
0505     def __getfield_byte(self):
0506         return self.__field_byte.getvalue()
0507 
0508     def __setfield_byte(self, value):
0509         if isinstance(value,UINT):
0510             self.__field_byte=value
0511         else:
0512             self.__field_byte=UINT(value,**{'sizeinbytes': 1})
0513 
0514     def __delfield_byte(self): del self.__field_byte
0515 
0516     byte=property(__getfield_byte, __setfield_byte, __delfield_byte, "individual byte of message")
0517 
0518     def iscontainer(self):
0519         return True
0520 
0521     def containerelements(self):
0522         yield ('byte', self.__field_byte, "individual byte of message")
0523 
0524 
0525 
0526 
0527 class recipient_record(BaseProtogenClass):
0528     __fields=['unknown1', 'number', 'status', 'timesent', 'timereceived', 'unknown2', 'unknown3']
0529 
0530     def __init__(self, *args, **kwargs):
0531         dict={}
0532         # What was supplied to this function
0533         dict.update(kwargs)
0534         # Parent constructor
0535         super(recipient_record,self).__init__(**dict)
0536         if self.__class__ is recipient_record:
0537             self._update(args,dict)
0538 
0539 
0540     def getfields(self):
0541         return self.__fields
0542 
0543 
0544     def _update(self, args, kwargs):
0545         super(recipient_record,self)._update(args,kwargs)
0546         keys=kwargs.keys()
0547         for key in keys:
0548             if key in self.__fields:
0549                 setattr(self, key, kwargs[key])
0550                 del kwargs[key]
0551         # Were any unrecognized kwargs passed in?
0552         if __debug__:
0553             self._complainaboutunusedargs(recipient_record,kwargs)
0554         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
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         self.__field_unknown1.writetobuffer(buf)
0562         self.__field_number.writetobuffer(buf)
0563         self.__field_status.writetobuffer(buf)
0564         self.__field_timesent.writetobuffer(buf)
0565         self.__field_timereceived.writetobuffer(buf)
0566         self.__field_unknown2.writetobuffer(buf)
0567         self.__field_unknown3.writetobuffer(buf)
0568         self._bufferendoffset=buf.getcurrentoffset()
0569         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0570 
0571 
0572     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0573         'Reads this packet from the supplied buffer'
0574         self._bufferstartoffset=buf.getcurrentoffset()
0575         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0576         self.__field_unknown1=DATA(**{'sizeinbytes': 33})
0577         self.__field_unknown1.readfrombuffer(buf)
0578         self.__field_number=USTRING(**{'sizeinbytes': 49})
0579         self.__field_number.readfrombuffer(buf)
0580         self.__field_status=UINT(**{'sizeinbytes': 1})
0581         self.__field_status.readfrombuffer(buf)
0582         self.__field_timesent=LGCALDATE(**{'sizeinbytes': 4})
0583         self.__field_timesent.readfrombuffer(buf)
0584         self.__field_timereceived=LGCALDATE(**{'sizeinbytes': 4})
0585         self.__field_timereceived.readfrombuffer(buf)
0586         self.__field_unknown2=UINT(**{'sizeinbytes': 1})
0587         self.__field_unknown2.readfrombuffer(buf)
0588         self.__field_unknown3=DATA(**{'sizeinbytes': 40})
0589         self.__field_unknown3.readfrombuffer(buf)
0590         self._bufferendoffset=buf.getcurrentoffset()
0591 
0592 
0593     def __getfield_unknown1(self):
0594         return self.__field_unknown1.getvalue()
0595 
0596     def __setfield_unknown1(self, value):
0597         if isinstance(value,DATA):
0598             self.__field_unknown1=value
0599         else:
0600             self.__field_unknown1=DATA(value,**{'sizeinbytes': 33})
0601 
0602     def __delfield_unknown1(self): del self.__field_unknown1
0603 
0604     unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None)
0605 
0606     def __getfield_number(self):
0607         return self.__field_number.getvalue()
0608 
0609     def __setfield_number(self, value):
0610         if isinstance(value,USTRING):
0611             self.__field_number=value
0612         else:
0613             self.__field_number=USTRING(value,**{'sizeinbytes': 49})
0614 
0615     def __delfield_number(self): del self.__field_number
0616 
0617     number=property(__getfield_number, __setfield_number, __delfield_number, None)
0618 
0619     def __getfield_status(self):
0620         return self.__field_status.getvalue()
0621 
0622     def __setfield_status(self, value):
0623         if isinstance(value,UINT):
0624             self.__field_status=value
0625         else:
0626             self.__field_status=UINT(value,**{'sizeinbytes': 1})
0627 
0628     def __delfield_status(self): del self.__field_status
0629 
0630     status=property(__getfield_status, __setfield_status, __delfield_status, None)
0631 
0632     def __getfield_timesent(self):
0633         return self.__field_timesent.getvalue()
0634 
0635     def __setfield_timesent(self, value):
0636         if isinstance(value,LGCALDATE):
0637             self.__field_timesent=value
0638         else:
0639             self.__field_timesent=LGCALDATE(value,**{'sizeinbytes': 4})
0640 
0641     def __delfield_timesent(self): del self.__field_timesent
0642 
0643     timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None)
0644 
0645     def __getfield_timereceived(self):
0646         return self.__field_timereceived.getvalue()
0647 
0648     def __setfield_timereceived(self, value):
0649         if isinstance(value,LGCALDATE):
0650             self.__field_timereceived=value
0651         else:
0652             self.__field_timereceived=LGCALDATE(value,**{'sizeinbytes': 4})
0653 
0654     def __delfield_timereceived(self): del self.__field_timereceived
0655 
0656     timereceived=property(__getfield_timereceived, __setfield_timereceived, __delfield_timereceived, None)
0657 
0658     def __getfield_unknown2(self):
0659         return self.__field_unknown2.getvalue()
0660 
0661     def __setfield_unknown2(self, value):
0662         if isinstance(value,UINT):
0663             self.__field_unknown2=value
0664         else:
0665             self.__field_unknown2=UINT(value,**{'sizeinbytes': 1})
0666 
0667     def __delfield_unknown2(self): del self.__field_unknown2
0668 
0669     unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None)
0670 
0671     def __getfield_unknown3(self):
0672         return self.__field_unknown3.getvalue()
0673 
0674     def __setfield_unknown3(self, value):
0675         if isinstance(value,DATA):
0676             self.__field_unknown3=value
0677         else:
0678             self.__field_unknown3=DATA(value,**{'sizeinbytes': 40})
0679 
0680     def __delfield_unknown3(self): del self.__field_unknown3
0681 
0682     unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None)
0683 
0684     def iscontainer(self):
0685         return True
0686 
0687     def containerelements(self):
0688         yield ('unknown1', self.__field_unknown1, None)
0689         yield ('number', self.__field_number, None)
0690         yield ('status', self.__field_status, None)
0691         yield ('timesent', self.__field_timesent, None)
0692         yield ('timereceived', self.__field_timereceived, None)
0693         yield ('unknown2', self.__field_unknown2, None)
0694         yield ('unknown3', self.__field_unknown3, None)
0695 
0696 
0697 
0698 
0699 class sms_saved(BaseProtogenClass):
0700     __fields=['outboxmsg', 'GPStime', 'outbox', 'inbox']
0701 
0702     def __init__(self, *args, **kwargs):
0703         dict={}
0704         # What was supplied to this function
0705         dict.update(kwargs)
0706         # Parent constructor
0707         super(sms_saved,self).__init__(**dict)
0708         if self.__class__ is sms_saved:
0709             self._update(args,dict)
0710 
0711 
0712     def getfields(self):
0713         return self.__fields
0714 
0715 
0716     def _update(self, args, kwargs):
0717         super(sms_saved,self)._update(args,kwargs)
0718         keys=kwargs.keys()
0719         for key in keys:
0720             if key in self.__fields:
0721                 setattr(self, key, kwargs[key])
0722                 del kwargs[key]
0723         # Were any unrecognized kwargs passed in?
0724         if __debug__:
0725             self._complainaboutunusedargs(sms_saved,kwargs)
0726         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0727         # Make all P fields that haven't already been constructed
0728 
0729 
0730     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0731         'Writes this packet to the supplied buffer'
0732         self._bufferstartoffset=buf.getcurrentoffset()
0733         self.__field_outboxmsg.writetobuffer(buf)
0734         self.__field_GPStime.writetobuffer(buf)
0735         if self.outboxmsg:
0736             self.__field_outbox.writetobuffer(buf)
0737         if not self.outboxmsg:
0738             self.__field_inbox.writetobuffer(buf)
0739         self._bufferendoffset=buf.getcurrentoffset()
0740         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0741 
0742 
0743     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0744         'Reads this packet from the supplied buffer'
0745         self._bufferstartoffset=buf.getcurrentoffset()
0746         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0747         self.__field_outboxmsg=UINT(**{'sizeinbytes': 4})
0748         self.__field_outboxmsg.readfrombuffer(buf)
0749         self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4})
0750         self.__field_GPStime.readfrombuffer(buf)
0751         if self.outboxmsg:
0752             self.__field_outbox=sms_out()
0753             self.__field_outbox.readfrombuffer(buf)
0754         if not self.outboxmsg:
0755             self.__field_inbox=sms_in()
0756             self.__field_inbox.readfrombuffer(buf)
0757         self._bufferendoffset=buf.getcurrentoffset()
0758 
0759 
0760     def __getfield_outboxmsg(self):
0761         return self.__field_outboxmsg.getvalue()
0762 
0763     def __setfield_outboxmsg(self, value):
0764         if isinstance(value,UINT):
0765             self.__field_outboxmsg=value
0766         else:
0767             self.__field_outboxmsg=UINT(value,**{'sizeinbytes': 4})
0768 
0769     def __delfield_outboxmsg(self): del self.__field_outboxmsg
0770 
0771     outboxmsg=property(__getfield_outboxmsg, __setfield_outboxmsg, __delfield_outboxmsg, None)
0772 
0773     def __getfield_GPStime(self):
0774         return self.__field_GPStime.getvalue()
0775 
0776     def __setfield_GPStime(self, value):
0777         if isinstance(value,GPSDATE):
0778             self.__field_GPStime=value
0779         else:
0780             self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4})
0781 
0782     def __delfield_GPStime(self): del self.__field_GPStime
0783 
0784     GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None)
0785 
0786     def __getfield_outbox(self):
0787         return self.__field_outbox.getvalue()
0788 
0789     def __setfield_outbox(self, value):
0790         if isinstance(value,sms_out):
0791             self.__field_outbox=value
0792         else:
0793             self.__field_outbox=sms_out(value,)
0794 
0795     def __delfield_outbox(self): del self.__field_outbox
0796 
0797     outbox=property(__getfield_outbox, __setfield_outbox, __delfield_outbox, None)
0798 
0799     def __getfield_inbox(self):
0800         return self.__field_inbox.getvalue()
0801 
0802     def __setfield_inbox(self, value):
0803         if isinstance(value,sms_in):
0804             self.__field_inbox=value
0805         else:
0806             self.__field_inbox=sms_in(value,)
0807 
0808     def __delfield_inbox(self): del self.__field_inbox
0809 
0810     inbox=property(__getfield_inbox, __setfield_inbox, __delfield_inbox, None)
0811 
0812     def iscontainer(self):
0813         return True
0814 
0815     def containerelements(self):
0816         yield ('outboxmsg', self.__field_outboxmsg, None)
0817         yield ('GPStime', self.__field_GPStime, None)
0818         if self.outboxmsg:
0819             yield ('outbox', self.__field_outbox, None)
0820         if not self.outboxmsg:
0821             yield ('inbox', self.__field_inbox, None)
0822 
0823 
0824 
0825 
0826 class sms_out(BaseProtogenClass):
0827     __fields=['index', 'unknown1', 'locked', 'timesent', 'unknown2', 'GPStime', 'subject', 'unknown4', 'num_msg_elements', 'messages', 'unknown1', 'priority', 'unknown5', 'callback', 'recipients', 'pad']
0828 
0829     def __init__(self, *args, **kwargs):
0830         dict={}
0831         # What was supplied to this function
0832         dict.update(kwargs)
0833         # Parent constructor
0834         super(sms_out,self).__init__(**dict)
0835         if self.__class__ is sms_out:
0836             self._update(args,dict)
0837 
0838 
0839     def getfields(self):
0840         return self.__fields
0841 
0842 
0843     def _update(self, args, kwargs):
0844         super(sms_out,self)._update(args,kwargs)
0845         keys=kwargs.keys()
0846         for key in keys:
0847             if key in self.__fields:
0848                 setattr(self, key, kwargs[key])
0849                 del kwargs[key]
0850         # Were any unrecognized kwargs passed in?
0851         if __debug__:
0852             self._complainaboutunusedargs(sms_out,kwargs)
0853         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0854         # Make all P fields that haven't already been constructed
0855 
0856 
0857     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0858         'Writes this packet to the supplied buffer'
0859         self._bufferstartoffset=buf.getcurrentoffset()
0860         self.__field_index.writetobuffer(buf)
0861         self.__field_unknown1.writetobuffer(buf)
0862         self.__field_locked.writetobuffer(buf)
0863         self.__field_timesent.writetobuffer(buf)
0864         self.__field_unknown2.writetobuffer(buf)
0865         self.__field_GPStime.writetobuffer(buf)
0866         self.__field_subject.writetobuffer(buf)
0867         self.__field_unknown4.writetobuffer(buf)
0868         self.__field_num_msg_elements.writetobuffer(buf)
0869         try: self.__field_messages
0870         except:
0871             self.__field_messages=LIST(**{'elementclass': msg_record, 'length': 7})
0872         self.__field_messages.writetobuffer(buf)
0873         self.__field_unknown1.writetobuffer(buf)
0874         self.__field_priority.writetobuffer(buf)
0875         self.__field_unknown5.writetobuffer(buf)
0876         self.__field_callback.writetobuffer(buf)
0877         try: self.__field_recipients
0878         except:
0879             self.__field_recipients=LIST(**{'elementclass': recipient_record,'length': 9})
0880         self.__field_recipients.writetobuffer(buf)
0881         self.__field_pad.writetobuffer(buf)
0882         self._bufferendoffset=buf.getcurrentoffset()
0883         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0884 
0885 
0886     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0887         'Reads this packet from the supplied buffer'
0888         self._bufferstartoffset=buf.getcurrentoffset()
0889         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0890         self.__field_index=UINT(**{'sizeinbytes': 4})
0891         self.__field_index.readfrombuffer(buf)
0892         self.__field_unknown1=UINT(**{'sizeinbytes': 1})
0893         self.__field_unknown1.readfrombuffer(buf)
0894         self.__field_locked=UINT(**{'sizeinbytes': 1})
0895         self.__field_locked.readfrombuffer(buf)
0896         self.__field_timesent=LGCALDATE(**{'sizeinbytes': 4})
0897         self.__field_timesent.readfrombuffer(buf)
0898         self.__field_unknown2=UINT(**{'sizeinbytes': 2})
0899         self.__field_unknown2.readfrombuffer(buf)
0900         self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4})
0901         self.__field_GPStime.readfrombuffer(buf)
0902         self.__field_subject=USTRING(**{'sizeinbytes': 21, 'encoding': PHONE_ENCODING})
0903         self.__field_subject.readfrombuffer(buf)
0904         self.__field_unknown4=UNKNOWN(**{'sizeinbytes': 1})
0905         self.__field_unknown4.readfrombuffer(buf)
0906         self.__field_num_msg_elements=UINT(**{'sizeinbytes': 1})
0907         self.__field_num_msg_elements.readfrombuffer(buf)
0908         self.__field_messages=LIST(**{'elementclass': msg_record, 'length': 7})
0909         self.__field_messages.readfrombuffer(buf)
0910         self.__field_unknown1=UNKNOWN(**{'sizeinbytes': 15})
0911         self.__field_unknown1.readfrombuffer(buf)
0912         self.__field_priority=UINT(**{'sizeinbytes': 1})
0913         self.__field_priority.readfrombuffer(buf)
0914         self.__field_unknown5=UNKNOWN(**{'sizeinbytes': 1})
0915         self.__field_unknown5.readfrombuffer(buf)
0916         self.__field_callback=USTRING(**{'sizeinbytes': 35})
0917         self.__field_callback.readfrombuffer(buf)
0918         self.__field_recipients=LIST(**{'elementclass': recipient_record,'length': 9})
0919         self.__field_recipients.readfrombuffer(buf)
0920         self.__field_pad=UNKNOWN()
0921         self.__field_pad.readfrombuffer(buf)
0922         self._bufferendoffset=buf.getcurrentoffset()
0923 
0924 
0925     def __getfield_index(self):
0926         return self.__field_index.getvalue()
0927 
0928     def __setfield_index(self, value):
0929         if isinstance(value,UINT):
0930             self.__field_index=value
0931         else:
0932             self.__field_index=UINT(value,**{'sizeinbytes': 4})
0933 
0934     def __delfield_index(self): del self.__field_index
0935 
0936     index=property(__getfield_index, __setfield_index, __delfield_index, None)
0937 
0938     def __getfield_unknown1(self):
0939         return self.__field_unknown1.getvalue()
0940 
0941     def __setfield_unknown1(self, value):
0942         if isinstance(value,UINT):
0943             self.__field_unknown1=value
0944         else:
0945             self.__field_unknown1=UINT(value,**{'sizeinbytes': 1})
0946 
0947     def __delfield_unknown1(self): del self.__field_unknown1
0948 
0949     unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None)
0950 
0951     def __getfield_locked(self):
0952         return self.__field_locked.getvalue()
0953 
0954     def __setfield_locked(self, value):
0955         if isinstance(value,UINT):
0956             self.__field_locked=value
0957         else:
0958             self.__field_locked=UINT(value,**{'sizeinbytes': 1})
0959 
0960     def __delfield_locked(self): del self.__field_locked
0961 
0962     locked=property(__getfield_locked, __setfield_locked, __delfield_locked, None)
0963 
0964     def __getfield_timesent(self):
0965         return self.__field_timesent.getvalue()
0966 
0967     def __setfield_timesent(self, value):
0968         if isinstance(value,LGCALDATE):
0969             self.__field_timesent=value
0970         else:
0971             self.__field_timesent=LGCALDATE(value,**{'sizeinbytes': 4})
0972 
0973     def __delfield_timesent(self): del self.__field_timesent
0974 
0975     timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None)
0976 
0977     def __getfield_unknown2(self):
0978         return self.__field_unknown2.getvalue()
0979 
0980     def __setfield_unknown2(self, value):
0981         if isinstance(value,UINT):
0982             self.__field_unknown2=value
0983         else:
0984             self.__field_unknown2=UINT(value,**{'sizeinbytes': 2})
0985 
0986     def __delfield_unknown2(self): del self.__field_unknown2
0987 
0988     unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None)
0989 
0990     def __getfield_GPStime(self):
0991         return self.__field_GPStime.getvalue()
0992 
0993     def __setfield_GPStime(self, value):
0994         if isinstance(value,GPSDATE):
0995             self.__field_GPStime=value
0996         else:
0997             self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4})
0998 
0999     def __delfield_GPStime(self): del self.__field_GPStime
1000 
1001     GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None)
1002 
1003     def __getfield_subject(self):
1004         return self.__field_subject.getvalue()
1005 
1006     def __setfield_subject(self, value):
1007         if isinstance(value,USTRING):
1008             self.__field_subject=value
1009         else:
1010             self.__field_subject=USTRING(value,**{'sizeinbytes': 21, 'encoding': PHONE_ENCODING})
1011 
1012     def __delfield_subject(self): del self.__field_subject
1013 
1014     subject=property(__getfield_subject, __setfield_subject, __delfield_subject, None)
1015 
1016     def __getfield_unknown4(self):
1017         return self.__field_unknown4.getvalue()
1018 
1019     def __setfield_unknown4(self, value):
1020         if isinstance(value,UNKNOWN):
1021             self.__field_unknown4=value
1022         else:
1023             self.__field_unknown4=UNKNOWN(value,**{'sizeinbytes': 1})
1024 
1025     def __delfield_unknown4(self): del self.__field_unknown4
1026 
1027     unknown4=property(__getfield_unknown4, __setfield_unknown4, __delfield_unknown4, None)
1028 
1029     def __getfield_num_msg_elements(self):
1030         return self.__field_num_msg_elements.getvalue()
1031 
1032     def __setfield_num_msg_elements(self, value):
1033         if isinstance(value,UINT):
1034             self.__field_num_msg_elements=value
1035         else:
1036             self.__field_num_msg_elements=UINT(value,**{'sizeinbytes': 1})
1037 
1038     def __delfield_num_msg_elements(self): del self.__field_num_msg_elements
1039 
1040     num_msg_elements=property(__getfield_num_msg_elements, __setfield_num_msg_elements, __delfield_num_msg_elements, None)
1041 
1042     def __getfield_messages(self):
1043         try: self.__field_messages
1044         except:
1045             self.__field_messages=LIST(**{'elementclass': msg_record, 'length': 7})
1046         return self.__field_messages.getvalue()
1047 
1048     def __setfield_messages(self, value):
1049         if isinstance(value,LIST):
1050             self.__field_messages=value
1051         else:
1052             self.__field_messages=LIST(value,**{'elementclass': msg_record, 'length': 7})
1053 
1054     def __delfield_messages(self): del self.__field_messages
1055 
1056     messages=property(__getfield_messages, __setfield_messages, __delfield_messages, None)
1057 
1058     def __getfield_unknown1(self):
1059         return self.__field_unknown1.getvalue()
1060 
1061     def __setfield_unknown1(self, value):
1062         if isinstance(value,UNKNOWN):
1063             self.__field_unknown1=value
1064         else:
1065             self.__field_unknown1=UNKNOWN(value,**{'sizeinbytes': 15})
1066 
1067     def __delfield_unknown1(self): del self.__field_unknown1
1068 
1069     unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None)
1070 
1071     def __getfield_priority(self):
1072         return self.__field_priority.getvalue()
1073 
1074     def __setfield_priority(self, value):
1075         if isinstance(value,UINT):
1076             self.__field_priority=value
1077         else:
1078             self.__field_priority=UINT(value,**{'sizeinbytes': 1})
1079 
1080     def __delfield_priority(self): del self.__field_priority
1081 
1082     priority=property(__getfield_priority, __setfield_priority, __delfield_priority, None)
1083 
1084     def __getfield_unknown5(self):
1085         return self.__field_unknown5.getvalue()
1086 
1087     def __setfield_unknown5(self, value):
1088         if isinstance(value,UNKNOWN):
1089             self.__field_unknown5=value
1090         else:
1091             self.__field_unknown5=UNKNOWN(value,**{'sizeinbytes': 1})
1092 
1093     def __delfield_unknown5(self): del self.__field_unknown5
1094 
1095     unknown5=property(__getfield_unknown5, __setfield_unknown5, __delfield_unknown5, None)
1096 
1097     def __getfield_callback(self):
1098         return self.__field_callback.getvalue()
1099 
1100     def __setfield_callback(self, value):
1101         if isinstance(value,USTRING):
1102             self.__field_callback=value
1103         else:
1104             self.__field_callback=USTRING(value,**{'sizeinbytes': 35})
1105 
1106     def __delfield_callback(self): del self.__field_callback
1107 
1108     callback=property(__getfield_callback, __setfield_callback, __delfield_callback, None)
1109 
1110     def __getfield_recipients(self):
1111         try: self.__field_recipients
1112         except:
1113             self.__field_recipients=LIST(**{'elementclass': recipient_record,'length': 9})
1114         return self.__field_recipients.getvalue()
1115 
1116     def __setfield_recipients(self, value):
1117         if isinstance(value,LIST):
1118             self.__field_recipients=value
1119         else:
1120             self.__field_recipients=LIST(value,**{'elementclass': recipient_record,'length': 9})
1121 
1122     def __delfield_recipients(self): del self.__field_recipients
1123 
1124     recipients=property(__getfield_recipients, __setfield_recipients, __delfield_recipients, None)
1125 
1126     def __getfield_pad(self):
1127         return self.__field_pad.getvalue()
1128 
1129     def __setfield_pad(self, value):
1130         if isinstance(value,UNKNOWN):
1131             self.__field_pad=value
1132         else:
1133             self.__field_pad=UNKNOWN(value,)
1134 
1135     def __delfield_pad(self): del self.__field_pad
1136 
1137     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
1138 
1139     def iscontainer(self):
1140         return True
1141 
1142     def containerelements(self):
1143         yield ('index', self.__field_index, None)
1144         yield ('unknown1', self.__field_unknown1, None)
1145         yield ('locked', self.__field_locked, None)
1146         yield ('timesent', self.__field_timesent, None)
1147         yield ('unknown2', self.__field_unknown2, None)
1148         yield ('GPStime', self.__field_GPStime, None)
1149         yield ('subject', self.__field_subject, None)
1150         yield ('unknown4', self.__field_unknown4, None)
1151         yield ('num_msg_elements', self.__field_num_msg_elements, None)
1152         yield ('messages', self.__field_messages, None)
1153         yield ('unknown1', self.__field_unknown1, None)
1154         yield ('priority', self.__field_priority, None)
1155         yield ('unknown5', self.__field_unknown5, None)
1156         yield ('callback', self.__field_callback, None)
1157         yield ('recipients', self.__field_recipients, None)
1158         yield ('pad', self.__field_pad, None)
1159 
1160 
1161 
1162 
1163 class SMSINBOXMSGFRAGMENT(BaseProtogenClass):
1164     __fields=['msg']
1165 
1166     def __init__(self, *args, **kwargs):
1167         dict={}
1168         # What was supplied to this function
1169         dict.update(kwargs)
1170         # Parent constructor
1171         super(SMSINBOXMSGFRAGMENT,self).__init__(**dict)
1172         if self.__class__ is SMSINBOXMSGFRAGMENT:
1173             self._update(args,dict)
1174 
1175 
1176     def getfields(self):
1177         return self.__fields
1178 
1179 
1180     def _update(self, args, kwargs):
1181         super(SMSINBOXMSGFRAGMENT,self)._update(args,kwargs)
1182         keys=kwargs.keys()
1183         for key in keys:
1184             if key in self.__fields:
1185                 setattr(self, key, kwargs[key])
1186                 del kwargs[key]
1187         # Were any unrecognized kwargs passed in?
1188         if __debug__:
1189             self._complainaboutunusedargs(SMSINBOXMSGFRAGMENT,kwargs)
1190         if len(args):
1191             dict2={'elementclass': _gen_p_lgvx5200_128, 'length': 181}
1192             dict2.update(kwargs)
1193             kwargs=dict2
1194             self.__field_msg=LIST(*args,**dict2)
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         try: self.__field_msg
1202         except:
1203             self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx5200_128, 'length': 181})
1204         self.__field_msg.writetobuffer(buf)
1205         self._bufferendoffset=buf.getcurrentoffset()
1206         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1207 
1208 
1209     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1210         'Reads this packet from the supplied buffer'
1211         self._bufferstartoffset=buf.getcurrentoffset()
1212         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1213         self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx5200_128, 'length': 181})
1214         self.__field_msg.readfrombuffer(buf)
1215         self._bufferendoffset=buf.getcurrentoffset()
1216 
1217 
1218     def __getfield_msg(self):
1219         try: self.__field_msg
1220         except:
1221             self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx5200_128, 'length': 181})
1222         return self.__field_msg.getvalue()
1223 
1224     def __setfield_msg(self, value):
1225         if isinstance(value,LIST):
1226             self.__field_msg=value
1227         else:
1228             self.__field_msg=LIST(value,**{'elementclass': _gen_p_lgvx5200_128, 'length': 181})
1229 
1230     def __delfield_msg(self): del self.__field_msg
1231 
1232     msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None)
1233 
1234     def iscontainer(self):
1235         return True
1236 
1237     def containerelements(self):
1238         yield ('msg', self.__field_msg, None)
1239 
1240 
1241 
1242 
1243 class _gen_p_lgvx5200_128(BaseProtogenClass):
1244     'Anonymous inner class'
1245     __fields=['byte']
1246 
1247     def __init__(self, *args, **kwargs):
1248         dict={}
1249         # What was supplied to this function
1250         dict.update(kwargs)
1251         # Parent constructor
1252         super(_gen_p_lgvx5200_128,self).__init__(**dict)
1253         if self.__class__ is _gen_p_lgvx5200_128:
1254             self._update(args,dict)
1255 
1256 
1257     def getfields(self):
1258         return self.__fields
1259 
1260 
1261     def _update(self, args, kwargs):
1262         super(_gen_p_lgvx5200_128,self)._update(args,kwargs)
1263         keys=kwargs.keys()
1264         for key in keys:
1265             if key in self.__fields:
1266                 setattr(self, key, kwargs[key])
1267                 del kwargs[key]
1268         # Were any unrecognized kwargs passed in?
1269         if __debug__:
1270             self._complainaboutunusedargs(_gen_p_lgvx5200_128,kwargs)
1271         if len(args):
1272             dict2={'sizeinbytes': 1}
1273             dict2.update(kwargs)
1274             kwargs=dict2
1275             self.__field_byte=UINT(*args,**dict2)
1276         # Make all P fields that haven't already been constructed
1277 
1278 
1279     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1280         'Writes this packet to the supplied buffer'
1281         self._bufferstartoffset=buf.getcurrentoffset()
1282         self.__field_byte.writetobuffer(buf)
1283         self._bufferendoffset=buf.getcurrentoffset()
1284         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1285 
1286 
1287     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1288         'Reads this packet from the supplied buffer'
1289         self._bufferstartoffset=buf.getcurrentoffset()
1290         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1291         self.__field_byte=UINT(**{'sizeinbytes': 1})
1292         self.__field_byte.readfrombuffer(buf)
1293         self._bufferendoffset=buf.getcurrentoffset()
1294 
1295 
1296     def __getfield_byte(self):
1297         return self.__field_byte.getvalue()
1298 
1299     def __setfield_byte(self, value):
1300         if isinstance(value,UINT):
1301             self.__field_byte=value
1302         else:
1303             self.__field_byte=UINT(value,**{'sizeinbytes': 1})
1304 
1305     def __delfield_byte(self): del self.__field_byte
1306 
1307     byte=property(__getfield_byte, __setfield_byte, __delfield_byte, "individual byte of message")
1308 
1309     def iscontainer(self):
1310         return True
1311 
1312     def containerelements(self):
1313         yield ('byte', self.__field_byte, "individual byte of message")
1314 
1315 
1316 
1317 
1318 class sms_in(BaseProtogenClass):
1319     __fields=['unknown1', 'timesent', 'unknown2', 'callback_length', 'callback', 'sender_length', 'sender', 'unknown3', 'lg_time', 'unknown4', 'GPStime', 'unknown5', 'read', 'locked', 'unknown6', 'priority', 'subject', 'bin_header1', 'bin_header2', 'unknown7', 'multipartID', 'bin_header3', 'num_msg_elements', 'msglengths', 'unknown8', 'msgs', 'unknown9']
1320 
1321     def __init__(self, *args, **kwargs):
1322         dict={}
1323         # What was supplied to this function
1324         dict.update(kwargs)
1325         # Parent constructor
1326         super(sms_in,self).__init__(**dict)
1327         if self.__class__ is sms_in:
1328             self._update(args,dict)
1329 
1330 
1331     def getfields(self):
1332         return self.__fields
1333 
1334 
1335     def _update(self, args, kwargs):
1336         super(sms_in,self)._update(args,kwargs)
1337         keys=kwargs.keys()
1338         for key in keys:
1339             if key in self.__fields:
1340                 setattr(self, key, kwargs[key])
1341                 del kwargs[key]
1342         # Were any unrecognized kwargs passed in?
1343         if __debug__:
1344             self._complainaboutunusedargs(sms_in,kwargs)
1345         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1346         # Make all P fields that haven't already been constructed
1347 
1348 
1349     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1350         'Writes this packet to the supplied buffer'
1351         self._bufferstartoffset=buf.getcurrentoffset()
1352         self.__field_unknown1.writetobuffer(buf)
1353         self.__field_timesent.writetobuffer(buf)
1354         self.__field_unknown2.writetobuffer(buf)
1355         self.__field_callback_length.writetobuffer(buf)
1356         self.__field_callback.writetobuffer(buf)
1357         self.__field_sender_length.writetobuffer(buf)
1358         try: self.__field_sender
1359         except:
1360             self.__field_sender=LIST(**{'elementclass': _gen_p_lgvx5200_138, 'length': 38})
1361         self.__field_sender.writetobuffer(buf)
1362         self.__field_unknown3.writetobuffer(buf)
1363         self.__field_lg_time.writetobuffer(buf)
1364         self.__field_unknown4.writetobuffer(buf)
1365         self.__field_GPStime.writetobuffer(buf)
1366         self.__field_unknown5.writetobuffer(buf)
1367         self.__field_read.writetobuffer(buf)
1368         self.__field_locked.writetobuffer(buf)
1369         self.__field_unknown6.writetobuffer(buf)
1370         self.__field_priority.writetobuffer(buf)
1371         self.__field_subject.writetobuffer(buf)
1372         self.__field_bin_header1.writetobuffer(buf)
1373         self.__field_bin_header2.writetobuffer(buf)
1374         self.__field_unknown7.writetobuffer(buf)
1375         self.__field_multipartID.writetobuffer(buf)
1376         self.__field_bin_header3.writetobuffer(buf)
1377         self.__field_num_msg_elements.writetobuffer(buf)
1378         try: self.__field_msglengths
1379         except:
1380             self.__field_msglengths=LIST(**{'elementclass': _gen_p_lgvx5200_156, 'length': 10})
1381         self.__field_msglengths.writetobuffer(buf)
1382         self.__field_unknown8.writetobuffer(buf)
1383         try: self.__field_msgs
1384         except:
1385             self.__field_msgs=LIST(**{'length': 10, 'elementclass': SMSINBOXMSGFRAGMENT})
1386         self.__field_msgs.writetobuffer(buf)
1387         self.__field_unknown9.writetobuffer(buf)
1388         self._bufferendoffset=buf.getcurrentoffset()
1389         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1390 
1391 
1392     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1393         'Reads this packet from the supplied buffer'
1394         self._bufferstartoffset=buf.getcurrentoffset()
1395         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1396         self.__field_unknown1=UNKNOWN(**{'sizeinbytes': 10})
1397         self.__field_unknown1.readfrombuffer(buf)
1398         self.__field_timesent=SMSDATE(**{'sizeinbytes': 6})
1399         self.__field_timesent.readfrombuffer(buf)
1400         self.__field_unknown2=UINT(**{'sizeinbytes': 3})
1401         self.__field_unknown2.readfrombuffer(buf)
1402         self.__field_callback_length=UINT(**{'sizeinbytes': 1})
1403         self.__field_callback_length.readfrombuffer(buf)
1404         self.__field_callback=USTRING(**{'sizeinbytes': 38})
1405         self.__field_callback.readfrombuffer(buf)
1406         self.__field_sender_length=UINT(**{'sizeinbytes': 1})
1407         self.__field_sender_length.readfrombuffer(buf)
1408         self.__field_sender=LIST(**{'elementclass': _gen_p_lgvx5200_138, 'length': 38})
1409         self.__field_sender.readfrombuffer(buf)
1410         self.__field_unknown3=DATA(**{'sizeinbytes': 12})
1411         self.__field_unknown3.readfrombuffer(buf)
1412         self.__field_lg_time=LGCALDATE(**{'sizeinbytes': 4})
1413         self.__field_lg_time.readfrombuffer(buf)
1414         self.__field_unknown4=UNKNOWN(**{'sizeinbytes': 3})
1415         self.__field_unknown4.readfrombuffer(buf)
1416         self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4})
1417         self.__field_GPStime.readfrombuffer(buf)
1418         self.__field_unknown5=UINT(**{'sizeinbytes': 4})
1419         self.__field_unknown5.readfrombuffer(buf)
1420         self.__field_read=UINT(**{'sizeinbytes': 1})
1421         self.__field_read.readfrombuffer(buf)
1422         self.__field_locked=UINT(**{'sizeinbytes': 1})
1423         self.__field_locked.readfrombuffer(buf)
1424         self.__field_unknown6=UINT(**{'sizeinbytes': 8})
1425         self.__field_unknown6.readfrombuffer(buf)
1426         self.__field_priority=UINT(**{'sizeinbytes': 1})
1427         self.__field_priority.readfrombuffer(buf)
1428         self.__field_subject=USTRING(**{'sizeinbytes': 21, 'encoding': PHONE_ENCODING})
1429         self.__field_subject.readfrombuffer(buf)
1430         self.__field_bin_header1=UINT(**{'sizeinbytes': 1})
1431         self.__field_bin_header1.readfrombuffer(buf)
1432         self.__field_bin_header2=UINT(**{'sizeinbytes': 1})
1433         self.__field_bin_header2.readfrombuffer(buf)
1434         self.__field_unknown7=UINT(**{'sizeinbytes': 4})
1435         self.__field_unknown7.readfrombuffer(buf)
1436         self.__field_multipartID=UINT(**{'sizeinbytes': 2})
1437         self.__field_multipartID.readfrombuffer(buf)
1438         self.__field_bin_header3=UINT(**{'sizeinbytes': 1})
1439         self.__field_bin_header3.readfrombuffer(buf)
1440         self.__field_num_msg_elements=UINT(**{'sizeinbytes': 1})
1441         self.__field_num_msg_elements.readfrombuffer(buf)
1442         self.__field_msglengths=LIST(**{'elementclass': _gen_p_lgvx5200_156, 'length': 10})
1443         self.__field_msglengths.readfrombuffer(buf)
1444         self.__field_unknown8=UNKNOWN(**{'sizeinbytes': 10})
1445         self.__field_unknown8.readfrombuffer(buf)
1446         self.__field_msgs=LIST(**{'length': 10, 'elementclass': SMSINBOXMSGFRAGMENT})
1447         self.__field_msgs.readfrombuffer(buf)
1448         self.__field_unknown9=UNKNOWN()
1449         self.__field_unknown9.readfrombuffer(buf)
1450         self._bufferendoffset=buf.getcurrentoffset()
1451 
1452 
1453     def __getfield_unknown1(self):
1454         return self.__field_unknown1.getvalue()
1455 
1456     def __setfield_unknown1(self, value):
1457         if isinstance(value,UNKNOWN):
1458             self.__field_unknown1=value
1459         else:
1460             self.__field_unknown1=UNKNOWN(value,**{'sizeinbytes': 10})
1461 
1462     def __delfield_unknown1(self): del self.__field_unknown1
1463 
1464     unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None)
1465 
1466     def __getfield_timesent(self):
1467         return self.__field_timesent.getvalue()
1468 
1469     def __setfield_timesent(self, value):
1470         if isinstance(value,SMSDATE):
1471             self.__field_timesent=value
1472         else:
1473             self.__field_timesent=SMSDATE(value,**{'sizeinbytes': 6})
1474 
1475     def __delfield_timesent(self): del self.__field_timesent
1476 
1477     timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None)
1478 
1479     def __getfield_unknown2(self):
1480         return self.__field_unknown2.getvalue()
1481 
1482     def __setfield_unknown2(self, value):
1483         if isinstance(value,UINT):
1484             self.__field_unknown2=value
1485         else:
1486             self.__field_unknown2=UINT(value,**{'sizeinbytes': 3})
1487 
1488     def __delfield_unknown2(self): del self.__field_unknown2
1489 
1490     unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None)
1491 
1492     def __getfield_callback_length(self):
1493         return self.__field_callback_length.getvalue()
1494 
1495     def __setfield_callback_length(self, value):
1496         if isinstance(value,UINT):
1497             self.__field_callback_length=value
1498         else:
1499             self.__field_callback_length=UINT(value,**{'sizeinbytes': 1})
1500 
1501     def __delfield_callback_length(self): del self.__field_callback_length
1502 
1503     callback_length=property(__getfield_callback_length, __setfield_callback_length, __delfield_callback_length, None)
1504 
1505     def __getfield_callback(self):
1506         return self.__field_callback.getvalue()
1507 
1508     def __setfield_callback(self, value):
1509         if isinstance(value,USTRING):
1510             self.__field_callback=value
1511         else:
1512             self.__field_callback=USTRING(value,**{'sizeinbytes': 38})
1513 
1514     def __delfield_callback(self): del self.__field_callback
1515 
1516     callback=property(__getfield_callback, __setfield_callback, __delfield_callback, None)
1517 
1518     def __getfield_sender_length(self):
1519         return self.__field_sender_length.getvalue()
1520 
1521     def __setfield_sender_length(self, value):
1522         if isinstance(value,UINT):
1523             self.__field_sender_length=value
1524         else:
1525             self.__field_sender_length=UINT(value,**{'sizeinbytes': 1})
1526 
1527     def __delfield_sender_length(self): del self.__field_sender_length
1528 
1529     sender_length=property(__getfield_sender_length, __setfield_sender_length, __delfield_sender_length, None)
1530 
1531     def __getfield_sender(self):
1532         try: self.__field_sender
1533         except:
1534             self.__field_sender=LIST(**{'elementclass': _gen_p_lgvx5200_138, 'length': 38})
1535         return self.__field_sender.getvalue()
1536 
1537     def __setfield_sender(self, value):
1538         if isinstance(value,LIST):
1539             self.__field_sender=value
1540         else:
1541             self.__field_sender=LIST(value,**{'elementclass': _gen_p_lgvx5200_138, 'length': 38})
1542 
1543     def __delfield_sender(self): del self.__field_sender
1544 
1545     sender=property(__getfield_sender, __setfield_sender, __delfield_sender, None)
1546 
1547     def __getfield_unknown3(self):
1548         return self.__field_unknown3.getvalue()
1549 
1550     def __setfield_unknown3(self, value):
1551         if isinstance(value,DATA):
1552             self.__field_unknown3=value
1553         else:
1554             self.__field_unknown3=DATA(value,**{'sizeinbytes': 12})
1555 
1556     def __delfield_unknown3(self): del self.__field_unknown3
1557 
1558     unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None)
1559 
1560     def __getfield_lg_time(self):
1561         return self.__field_lg_time.getvalue()
1562 
1563     def __setfield_lg_time(self, value):
1564         if isinstance(value,LGCALDATE):
1565             self.__field_lg_time=value
1566         else:
1567             self.__field_lg_time=LGCALDATE(value,**{'sizeinbytes': 4})
1568 
1569     def __delfield_lg_time(self): del self.__field_lg_time
1570 
1571     lg_time=property(__getfield_lg_time, __setfield_lg_time, __delfield_lg_time, None)
1572 
1573     def __getfield_unknown4(self):
1574         return self.__field_unknown4.getvalue()
1575 
1576     def __setfield_unknown4(self, value):
1577         if isinstance(value,UNKNOWN):
1578             self.__field_unknown4=value
1579         else:
1580             self.__field_unknown4=UNKNOWN(value,**{'sizeinbytes': 3})
1581 
1582     def __delfield_unknown4(self): del self.__field_unknown4
1583 
1584     unknown4=property(__getfield_unknown4, __setfield_unknown4, __delfield_unknown4, None)
1585 
1586     def __getfield_GPStime(self):
1587         return self.__field_GPStime.getvalue()
1588 
1589     def __setfield_GPStime(self, value):
1590         if isinstance(value,GPSDATE):
1591             self.__field_GPStime=value
1592         else:
1593             self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4})
1594 
1595     def __delfield_GPStime(self): del self.__field_GPStime
1596 
1597     GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None)
1598 
1599     def __getfield_unknown5(self):
1600         return self.__field_unknown5.getvalue()
1601 
1602     def __setfield_unknown5(self, value):
1603         if isinstance(value,UINT):
1604             self.__field_unknown5=value
1605         else:
1606             self.__field_unknown5=UINT(value,**{'sizeinbytes': 4})
1607 
1608     def __delfield_unknown5(self): del self.__field_unknown5
1609 
1610     unknown5=property(__getfield_unknown5, __setfield_unknown5, __delfield_unknown5, None)
1611 
1612     def __getfield_read(self):
1613         return self.__field_read.getvalue()
1614 
1615     def __setfield_read(self, value):
1616         if isinstance(value,UINT):
1617             self.__field_read=value
1618         else:
1619             self.__field_read=UINT(value,**{'sizeinbytes': 1})
1620 
1621     def __delfield_read(self): del self.__field_read
1622 
1623     read=property(__getfield_read, __setfield_read, __delfield_read, None)
1624 
1625     def __getfield_locked(self):
1626         return self.__field_locked.getvalue()
1627 
1628     def __setfield_locked(self, value):
1629         if isinstance(value,UINT):
1630             self.__field_locked=value
1631         else:
1632             self.__field_locked=UINT(value,**{'sizeinbytes': 1})
1633 
1634     def __delfield_locked(self): del self.__field_locked
1635 
1636     locked=property(__getfield_locked, __setfield_locked, __delfield_locked, None)
1637 
1638     def __getfield_unknown6(self):
1639         return self.__field_unknown6.getvalue()
1640 
1641     def __setfield_unknown6(self, value):
1642         if isinstance(value,UINT):
1643             self.__field_unknown6=value
1644         else:
1645             self.__field_unknown6=UINT(value,**{'sizeinbytes': 8})
1646 
1647     def __delfield_unknown6(self): del self.__field_unknown6
1648 
1649     unknown6=property(__getfield_unknown6, __setfield_unknown6, __delfield_unknown6, None)
1650 
1651     def __getfield_priority(self):
1652         return self.__field_priority.getvalue()
1653 
1654     def __setfield_priority(self, value):
1655         if isinstance(value,UINT):
1656             self.__field_priority=value
1657         else:
1658             self.__field_priority=UINT(value,**{'sizeinbytes': 1})
1659 
1660     def __delfield_priority(self): del self.__field_priority
1661 
1662     priority=property(__getfield_priority, __setfield_priority, __delfield_priority, None)
1663 
1664     def __getfield_subject(self):
1665         return self.__field_subject.getvalue()
1666 
1667     def __setfield_subject(self, value):
1668         if isinstance(value,USTRING):
1669             self.__field_subject=value
1670         else:
1671             self.__field_subject=USTRING(value,**{'sizeinbytes': 21, 'encoding': PHONE_ENCODING})
1672 
1673     def __delfield_subject(self): del self.__field_subject
1674 
1675     subject=property(__getfield_subject, __setfield_subject, __delfield_subject, None)
1676 
1677     def __getfield_bin_header1(self):
1678         return self.__field_bin_header1.getvalue()
1679 
1680     def __setfield_bin_header1(self, value):
1681         if isinstance(value,UINT):
1682             self.__field_bin_header1=value
1683         else:
1684             self.__field_bin_header1=UINT(value,**{'sizeinbytes': 1})
1685 
1686     def __delfield_bin_header1(self): del self.__field_bin_header1
1687 
1688     bin_header1=property(__getfield_bin_header1, __setfield_bin_header1, __delfield_bin_header1, None)
1689 
1690     def __getfield_bin_header2(self):
1691         return self.__field_bin_header2.getvalue()
1692 
1693     def __setfield_bin_header2(self, value):
1694         if isinstance(value,UINT):
1695             self.__field_bin_header2=value
1696         else:
1697             self.__field_bin_header2=UINT(value,**{'sizeinbytes': 1})
1698 
1699     def __delfield_bin_header2(self): del self.__field_bin_header2
1700 
1701     bin_header2=property(__getfield_bin_header2, __setfield_bin_header2, __delfield_bin_header2, None)
1702 
1703     def __getfield_unknown7(self):
1704         return self.__field_unknown7.getvalue()
1705 
1706     def __setfield_unknown7(self, value):
1707         if isinstance(value,UINT):
1708             self.__field_unknown7=value
1709         else:
1710             self.__field_unknown7=UINT(value,**{'sizeinbytes': 4})
1711 
1712     def __delfield_unknown7(self): del self.__field_unknown7
1713 
1714     unknown7=property(__getfield_unknown7, __setfield_unknown7, __delfield_unknown7, None)
1715 
1716     def __getfield_multipartID(self):
1717         return self.__field_multipartID.getvalue()
1718 
1719     def __setfield_multipartID(self, value):
1720         if isinstance(value,UINT):
1721             self.__field_multipartID=value
1722         else:
1723             self.__field_multipartID=UINT(value,**{'sizeinbytes': 2})
1724 
1725     def __delfield_multipartID(self): del self.__field_multipartID
1726 
1727     multipartID=property(__getfield_multipartID, __setfield_multipartID, __delfield_multipartID, None)
1728 
1729     def __getfield_bin_header3(self):
1730         return self.__field_bin_header3.getvalue()
1731 
1732     def __setfield_bin_header3(self, value):
1733         if isinstance(value,UINT):
1734             self.__field_bin_header3=value
1735         else:
1736             self.__field_bin_header3=UINT(value,**{'sizeinbytes': 1})
1737 
1738     def __delfield_bin_header3(self): del self.__field_bin_header3
1739 
1740     bin_header3=property(__getfield_bin_header3, __setfield_bin_header3, __delfield_bin_header3, None)
1741 
1742     def __getfield_num_msg_elements(self):
1743         return self.__field_num_msg_elements.getvalue()
1744 
1745     def __setfield_num_msg_elements(self, value):
1746         if isinstance(value,UINT):
1747             self.__field_num_msg_elements=value
1748         else:
1749             self.__field_num_msg_elements=UINT(value,**{'sizeinbytes': 1})
1750 
1751     def __delfield_num_msg_elements(self): del self.__field_num_msg_elements
1752 
1753     num_msg_elements=property(__getfield_num_msg_elements, __setfield_num_msg_elements, __delfield_num_msg_elements, None)
1754 
1755     def __getfield_msglengths(self):
1756         try: self.__field_msglengths
1757         except:
1758             self.__field_msglengths=LIST(**{'elementclass': _gen_p_lgvx5200_156, 'length': 10})
1759         return self.__field_msglengths.getvalue()
1760 
1761     def __setfield_msglengths(self, value):
1762         if isinstance(value,LIST):
1763             self.__field_msglengths=value
1764         else:
1765             self.__field_msglengths=LIST(value,**{'elementclass': _gen_p_lgvx5200_156, 'length': 10})
1766 
1767     def __delfield_msglengths(self): del self.__field_msglengths
1768 
1769     msglengths=property(__getfield_msglengths, __setfield_msglengths, __delfield_msglengths, None)
1770 
1771     def __getfield_unknown8(self):
1772         return self.__field_unknown8.getvalue()
1773 
1774     def __setfield_unknown8(self, value):
1775         if isinstance(value,UNKNOWN):
1776             self.__field_unknown8=value
1777         else:
1778             self.__field_unknown8=UNKNOWN(value,**{'sizeinbytes': 10})
1779 
1780     def __delfield_unknown8(self): del self.__field_unknown8
1781 
1782     unknown8=property(__getfield_unknown8, __setfield_unknown8, __delfield_unknown8, None)
1783 
1784     def __getfield_msgs(self):
1785         try: self.__field_msgs
1786         except:
1787             self.__field_msgs=LIST(**{'length': 10, 'elementclass': SMSINBOXMSGFRAGMENT})
1788         return self.__field_msgs.getvalue()
1789 
1790     def __setfield_msgs(self, value):
1791         if isinstance(value,LIST):
1792             self.__field_msgs=value
1793         else:
1794             self.__field_msgs=LIST(value,**{'length': 10, 'elementclass': SMSINBOXMSGFRAGMENT})
1795 
1796     def __delfield_msgs(self): del self.__field_msgs
1797 
1798     msgs=property(__getfield_msgs, __setfield_msgs, __delfield_msgs, None)
1799 
1800     def __getfield_unknown9(self):
1801         return self.__field_unknown9.getvalue()
1802 
1803     def __setfield_unknown9(self, value):
1804         if isinstance(value,UNKNOWN):
1805             self.__field_unknown9=value
1806         else:
1807             self.__field_unknown9=UNKNOWN(value,)
1808 
1809     def __delfield_unknown9(self): del self.__field_unknown9
1810 
1811     unknown9=property(__getfield_unknown9, __setfield_unknown9, __delfield_unknown9, None)
1812 
1813     def iscontainer(self):
1814         return True
1815 
1816     def containerelements(self):
1817         yield ('unknown1', self.__field_unknown1, None)
1818         yield ('timesent', self.__field_timesent, None)
1819         yield ('unknown2', self.__field_unknown2, None)
1820         yield ('callback_length', self.__field_callback_length, None)
1821         yield ('callback', self.__field_callback, None)
1822         yield ('sender_length', self.__field_sender_length, None)
1823         yield ('sender', self.__field_sender, None)
1824         yield ('unknown3', self.__field_unknown3, None)
1825         yield ('lg_time', self.__field_lg_time, None)
1826         yield ('unknown4', self.__field_unknown4, None)
1827         yield ('GPStime', self.__field_GPStime, None)
1828         yield ('unknown5', self.__field_unknown5, None)
1829         yield ('read', self.__field_read, None)
1830         yield ('locked', self.__field_locked, None)
1831         yield ('unknown6', self.__field_unknown6, None)
1832         yield ('priority', self.__field_priority, None)
1833         yield ('subject', self.__field_subject, None)
1834         yield ('bin_header1', self.__field_bin_header1, None)
1835         yield ('bin_header2', self.__field_bin_header2, None)
1836         yield ('unknown7', self.__field_unknown7, None)
1837         yield ('multipartID', self.__field_multipartID, None)
1838         yield ('bin_header3', self.__field_bin_header3, None)
1839         yield ('num_msg_elements', self.__field_num_msg_elements, None)
1840         yield ('msglengths', self.__field_msglengths, None)
1841         yield ('unknown8', self.__field_unknown8, None)
1842         yield ('msgs', self.__field_msgs, None)
1843         yield ('unknown9', self.__field_unknown9, None)
1844 
1845 
1846 
1847 
1848 class _gen_p_lgvx5200_138(BaseProtogenClass):
1849     'Anonymous inner class'
1850     __fields=['byte']
1851 
1852     def __init__(self, *args, **kwargs):
1853         dict={}
1854         # What was supplied to this function
1855         dict.update(kwargs)
1856         # Parent constructor
1857         super(_gen_p_lgvx5200_138,self).__init__(**dict)
1858         if self.__class__ is _gen_p_lgvx5200_138:
1859             self._update(args,dict)
1860 
1861 
1862     def getfields(self):
1863         return self.__fields
1864 
1865 
1866     def _update(self, args, kwargs):
1867         super(_gen_p_lgvx5200_138,self)._update(args,kwargs)
1868         keys=kwargs.keys()
1869         for key in keys:
1870             if key in self.__fields:
1871                 setattr(self, key, kwargs[key])
1872                 del kwargs[key]
1873         # Were any unrecognized kwargs passed in?
1874         if __debug__:
1875             self._complainaboutunusedargs(_gen_p_lgvx5200_138,kwargs)
1876         if len(args):
1877             dict2={'sizeinbytes': 1}
1878             dict2.update(kwargs)
1879             kwargs=dict2
1880             self.__field_byte=UINT(*args,**dict2)
1881         # Make all P fields that haven't already been constructed
1882 
1883 
1884     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1885         'Writes this packet to the supplied buffer'
1886         self._bufferstartoffset=buf.getcurrentoffset()
1887         self.__field_byte.writetobuffer(buf)
1888         self._bufferendoffset=buf.getcurrentoffset()
1889         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1890 
1891 
1892     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1893         'Reads this packet from the supplied buffer'
1894         self._bufferstartoffset=buf.getcurrentoffset()
1895         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1896         self.__field_byte=UINT(**{'sizeinbytes': 1})
1897         self.__field_byte.readfrombuffer(buf)
1898         self._bufferendoffset=buf.getcurrentoffset()
1899 
1900 
1901     def __getfield_byte(self):
1902         return self.__field_byte.getvalue()
1903 
1904     def __setfield_byte(self, value):
1905         if isinstance(value,UINT):
1906             self.__field_byte=value
1907         else:
1908             self.__field_byte=UINT(value,**{'sizeinbytes': 1})
1909 
1910     def __delfield_byte(self): del self.__field_byte
1911 
1912     byte=property(__getfield_byte, __setfield_byte, __delfield_byte, "individual byte of senders phone number")
1913 
1914     def iscontainer(self):
1915         return True
1916 
1917     def containerelements(self):
1918         yield ('byte', self.__field_byte, "individual byte of senders phone number")
1919 
1920 
1921 
1922 
1923 class _gen_p_lgvx5200_156(BaseProtogenClass):
1924     'Anonymous inner class'
1925     __fields=['msglength']
1926 
1927     def __init__(self, *args, **kwargs):
1928         dict={}
1929         # What was supplied to this function
1930         dict.update(kwargs)
1931         # Parent constructor
1932         super(_gen_p_lgvx5200_156,self).__init__(**dict)
1933         if self.__class__ is _gen_p_lgvx5200_156:
1934             self._update(args,dict)
1935 
1936 
1937     def getfields(self):
1938         return self.__fields
1939 
1940 
1941     def _update(self, args, kwargs):
1942         super(_gen_p_lgvx5200_156,self)._update(args,kwargs)
1943         keys=kwargs.keys()
1944         for key in keys:
1945             if key in self.__fields:
1946                 setattr(self, key, kwargs[key])
1947                 del kwargs[key]
1948         # Were any unrecognized kwargs passed in?
1949         if __debug__:
1950             self._complainaboutunusedargs(_gen_p_lgvx5200_156,kwargs)
1951         if len(args):
1952             dict2={'sizeinbytes': 1}
1953             dict2.update(kwargs)
1954             kwargs=dict2
1955             self.__field_msglength=UINT(*args,**dict2)
1956         # Make all P fields that haven't already been constructed
1957 
1958 
1959     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1960         'Writes this packet to the supplied buffer'
1961         self._bufferstartoffset=buf.getcurrentoffset()
1962         self.__field_msglength.writetobuffer(buf)
1963         self._bufferendoffset=buf.getcurrentoffset()
1964         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1965 
1966 
1967     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1968         'Reads this packet from the supplied buffer'
1969         self._bufferstartoffset=buf.getcurrentoffset()
1970         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1971         self.__field_msglength=UINT(**{'sizeinbytes': 1})
1972         self.__field_msglength.readfrombuffer(buf)
1973         self._bufferendoffset=buf.getcurrentoffset()
1974 
1975 
1976     def __getfield_msglength(self):
1977         return self.__field_msglength.getvalue()
1978 
1979     def __setfield_msglength(self, value):
1980         if isinstance(value,UINT):
1981             self.__field_msglength=value
1982         else:
1983             self.__field_msglength=UINT(value,**{'sizeinbytes': 1})
1984 
1985     def __delfield_msglength(self): del self.__field_msglength
1986 
1987     msglength=property(__getfield_msglength, __setfield_msglength, __delfield_msglength, "lengths of individual messages in septets")
1988 
1989     def iscontainer(self):
1990         return True
1991 
1992     def containerelements(self):
1993         yield ('msglength', self.__field_msglength, "lengths of individual messages in septets")
1994 
1995 
1996 
1997 
1998 class sms_quick_text(BaseProtogenClass):
1999     __fields=['msgs']
2000 
2001     def __init__(self, *args, **kwargs):
2002         dict={}
2003         # What was supplied to this function
2004         dict.update(kwargs)
2005         # Parent constructor
2006         super(sms_quick_text,self).__init__(**dict)
2007         if self.__class__ is sms_quick_text:
2008             self._update(args,dict)
2009 
2010 
2011     def getfields(self):
2012         return self.__fields
2013 
2014 
2015     def _update(self, args, kwargs):
2016         super(sms_quick_text,self)._update(args,kwargs)
2017         keys=kwargs.keys()
2018         for key in keys:
2019             if key in self.__fields:
2020                 setattr(self, key, kwargs[key])
2021                 del kwargs[key]
2022         # Were any unrecognized kwargs passed in?
2023         if __debug__:
2024             self._complainaboutunusedargs(sms_quick_text,kwargs)
2025         if len(args):
2026             dict2={'elementclass': _gen_p_lgvx5200_169,  'length': SMS_CANNED_MAX_ITEMS, 'createdefault': True}
2027             dict2.update(kwargs)
2028             kwargs=dict2
2029             self.__field_msgs=LIST(*args,**dict2)
2030         # Make all P fields that haven't already been constructed
2031 
2032 
2033     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2034         'Writes this packet to the supplied buffer'
2035         self._bufferstartoffset=buf.getcurrentoffset()
2036         try: self.__field_msgs
2037         except:
2038             self.__field_msgs=LIST(**{'elementclass': _gen_p_lgvx5200_169,  'length': SMS_CANNED_MAX_ITEMS, 'createdefault': True})
2039         self.__field_msgs.writetobuffer(buf)
2040         self._bufferendoffset=buf.getcurrentoffset()
2041         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2042 
2043 
2044     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2045         'Reads this packet from the supplied buffer'
2046         self._bufferstartoffset=buf.getcurrentoffset()
2047         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2048         self.__field_msgs=LIST(**{'elementclass': _gen_p_lgvx5200_169,  'length': SMS_CANNED_MAX_ITEMS, 'createdefault': True})
2049         self.__field_msgs.readfrombuffer(buf)
2050         self._bufferendoffset=buf.getcurrentoffset()
2051 
2052 
2053     def __getfield_msgs(self):
2054         try: self.__field_msgs
2055         except:
2056             self.__field_msgs=LIST(**{'elementclass': _gen_p_lgvx5200_169,  'length': SMS_CANNED_MAX_ITEMS, 'createdefault': True})
2057         return self.__field_msgs.getvalue()
2058 
2059     def __setfield_msgs(self, value):
2060         if isinstance(value,LIST):
2061             self.__field_msgs=value
2062         else:
2063             self.__field_msgs=LIST(value,**{'elementclass': _gen_p_lgvx5200_169,  'length': SMS_CANNED_MAX_ITEMS, 'createdefault': True})
2064 
2065     def __delfield_msgs(self): del self.__field_msgs
2066 
2067     msgs=property(__getfield_msgs, __setfield_msgs, __delfield_msgs, None)
2068 
2069     def iscontainer(self):
2070         return True
2071 
2072     def containerelements(self):
2073         yield ('msgs', self.__field_msgs, None)
2074 
2075 
2076 
2077 
2078 class _gen_p_lgvx5200_169(BaseProtogenClass):
2079     'Anonymous inner class'
2080     __fields=['msg']
2081 
2082     def __init__(self, *args, **kwargs):
2083         dict={}
2084         # What was supplied to this function
2085         dict.update(kwargs)
2086         # Parent constructor
2087         super(_gen_p_lgvx5200_169,self).__init__(**dict)
2088         if self.__class__ is _gen_p_lgvx5200_169:
2089             self._update(args,dict)
2090 
2091 
2092     def getfields(self):
2093         return self.__fields
2094 
2095 
2096     def _update(self, args, kwargs):
2097         super(_gen_p_lgvx5200_169,self)._update(args,kwargs)
2098         keys=kwargs.keys()
2099         for key in keys:
2100             if key in self.__fields:
2101                 setattr(self, key, kwargs[key])
2102                 del kwargs[key]
2103         # Were any unrecognized kwargs passed in?
2104         if __debug__:
2105             self._complainaboutunusedargs(_gen_p_lgvx5200_169,kwargs)
2106         if len(args):
2107             dict2={'sizeinbytes': 101, 'encoding': PHONE_ENCODING, 'default': ""}
2108             dict2.update(kwargs)
2109             kwargs=dict2
2110             self.__field_msg=USTRING(*args,**dict2)
2111         # Make all P fields that haven't already been constructed
2112 
2113 
2114     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2115         'Writes this packet to the supplied buffer'
2116         self._bufferstartoffset=buf.getcurrentoffset()
2117         try: self.__field_msg
2118         except:
2119             self.__field_msg=USTRING(**{'sizeinbytes': 101, 'encoding': PHONE_ENCODING, 'default': ""})
2120         self.__field_msg.writetobuffer(buf)
2121         self._bufferendoffset=buf.getcurrentoffset()
2122         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2123 
2124 
2125     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2126         'Reads this packet from the supplied buffer'
2127         self._bufferstartoffset=buf.getcurrentoffset()
2128         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2129         self.__field_msg=USTRING(**{'sizeinbytes': 101, 'encoding': PHONE_ENCODING, 'default': ""})
2130         self.__field_msg.readfrombuffer(buf)
2131         self._bufferendoffset=buf.getcurrentoffset()
2132 
2133 
2134     def __getfield_msg(self):
2135         try: self.__field_msg
2136         except:
2137             self.__field_msg=USTRING(**{'sizeinbytes': 101, 'encoding': PHONE_ENCODING, 'default': ""})
2138         return self.__field_msg.getvalue()
2139 
2140     def __setfield_msg(self, value):
2141         if isinstance(value,USTRING):
2142             self.__field_msg=value
2143         else:
2144             self.__field_msg=USTRING(value,**{'sizeinbytes': 101, 'encoding': PHONE_ENCODING, 'default': ""})
2145 
2146     def __delfield_msg(self): del self.__field_msg
2147 
2148     msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None)
2149 
2150     def iscontainer(self):
2151         return True
2152 
2153     def containerelements(self):
2154         yield ('msg', self.__field_msg, None)
2155 
2156 
2157 
2158 
2159 class textmemo(BaseProtogenClass):
2160     __fields=['dunno', 'GPStime', 'memotime', 'text']
2161 
2162     def __init__(self, *args, **kwargs):
2163         dict={}
2164         # What was supplied to this function
2165         dict.update(kwargs)
2166         # Parent constructor
2167         super(textmemo,self).__init__(**dict)
2168         if self.__class__ is textmemo:
2169             self._update(args,dict)
2170 
2171 
2172     def getfields(self):
2173         return self.__fields
2174 
2175 
2176     def _update(self, args, kwargs):
2177         super(textmemo,self)._update(args,kwargs)
2178         keys=kwargs.keys()
2179         for key in keys:
2180             if key in self.__fields:
2181                 setattr(self, key, kwargs[key])
2182                 del kwargs[key]
2183         # Were any unrecognized kwargs passed in?
2184         if __debug__:
2185             self._complainaboutunusedargs(textmemo,kwargs)
2186         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2187         # Make all P fields that haven't already been constructed
2188 
2189 
2190     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2191         'Writes this packet to the supplied buffer'
2192         self._bufferstartoffset=buf.getcurrentoffset()
2193         try: self.__field_dunno
2194         except:
2195             self.__field_dunno=UINT(**{'sizeinbytes': 4,  'constant':1 })
2196         self.__field_dunno.writetobuffer(buf)
2197         self.__field_GPStime.writetobuffer(buf)
2198         self.__field_memotime.writetobuffer(buf)
2199         self.__field_text.writetobuffer(buf)
2200         self._bufferendoffset=buf.getcurrentoffset()
2201         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2202 
2203 
2204     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2205         'Reads this packet from the supplied buffer'
2206         self._bufferstartoffset=buf.getcurrentoffset()
2207         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2208         self.__field_dunno=UINT(**{'sizeinbytes': 4,  'constant':1 })
2209         self.__field_dunno.readfrombuffer(buf)
2210         self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4})
2211         self.__field_GPStime.readfrombuffer(buf)
2212         self.__field_memotime=LGCALDATE(**{'sizeinbytes': 4})
2213         self.__field_memotime.readfrombuffer(buf)
2214         self.__field_text=USTRING(**{'sizeinbytes': 152, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False })
2215         self.__field_text.readfrombuffer(buf)
2216         self._bufferendoffset=buf.getcurrentoffset()
2217 
2218 
2219     def __getfield_dunno(self):
2220         try: self.__field_dunno
2221         except:
2222             self.__field_dunno=UINT(**{'sizeinbytes': 4,  'constant':1 })
2223         return self.__field_dunno.getvalue()
2224 
2225     def __setfield_dunno(self, value):
2226         if isinstance(value,UINT):
2227             self.__field_dunno=value
2228         else:
2229             self.__field_dunno=UINT(value,**{'sizeinbytes': 4,  'constant':1 })
2230 
2231     def __delfield_dunno(self): del self.__field_dunno
2232 
2233     dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, None)
2234 
2235     def __getfield_GPStime(self):
2236         return self.__field_GPStime.getvalue()
2237 
2238     def __setfield_GPStime(self, value):
2239         if isinstance(value,GPSDATE):
2240             self.__field_GPStime=value
2241         else:
2242             self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4})
2243 
2244     def __delfield_GPStime(self): del self.__field_GPStime
2245 
2246     GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None)
2247 
2248     def __getfield_memotime(self):
2249         return self.__field_memotime.getvalue()
2250 
2251     def __setfield_memotime(self, value):
2252         if isinstance(value,LGCALDATE):
2253             self.__field_memotime=value
2254         else:
2255             self.__field_memotime=LGCALDATE(value,**{'sizeinbytes': 4})
2256 
2257     def __delfield_memotime(self): del self.__field_memotime
2258 
2259     memotime=property(__getfield_memotime, __setfield_memotime, __delfield_memotime, None)
2260 
2261     def __getfield_text(self):
2262         return self.__field_text.getvalue()
2263 
2264     def __setfield_text(self, value):
2265         if isinstance(value,USTRING):
2266             self.__field_text=value
2267         else:
2268             self.__field_text=USTRING(value,**{'sizeinbytes': 152, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False })
2269 
2270     def __delfield_text(self): del self.__field_text
2271 
2272     text=property(__getfield_text, __setfield_text, __delfield_text, None)
2273 
2274     def iscontainer(self):
2275         return True
2276 
2277     def containerelements(self):
2278         yield ('dunno', self.__field_dunno, None)
2279         yield ('GPStime', self.__field_GPStime, None)
2280         yield ('memotime', self.__field_memotime, None)
2281         yield ('text', self.__field_text, None)
2282 
2283 
2284 
2285 
2286 class textmemofile(BaseProtogenClass):
2287     __fields=['itemcount', 'items']
2288 
2289     def __init__(self, *args, **kwargs):
2290         dict={}
2291         # What was supplied to this function
2292         dict.update(kwargs)
2293         # Parent constructor
2294         super(textmemofile,self).__init__(**dict)
2295         if self.__class__ is textmemofile:
2296             self._update(args,dict)
2297 
2298 
2299     def getfields(self):
2300         return self.__fields
2301 
2302 
2303     def _update(self, args, kwargs):
2304         super(textmemofile,self)._update(args,kwargs)
2305         keys=kwargs.keys()
2306         for key in keys:
2307             if key in self.__fields:
2308                 setattr(self, key, kwargs[key])
2309                 del kwargs[key]
2310         # Were any unrecognized kwargs passed in?
2311         if __debug__:
2312             self._complainaboutunusedargs(textmemofile,kwargs)
2313         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2314         # Make all P fields that haven't already been constructed
2315 
2316 
2317     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2318         'Writes this packet to the supplied buffer'
2319         self._bufferstartoffset=buf.getcurrentoffset()
2320         self.__field_itemcount.writetobuffer(buf)
2321         try: self.__field_items
2322         except:
2323             self.__field_items=LIST(**{ 'elementclass': textmemo })
2324         self.__field_items.writetobuffer(buf)
2325         self._bufferendoffset=buf.getcurrentoffset()
2326         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2327 
2328 
2329     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2330         'Reads this packet from the supplied buffer'
2331         self._bufferstartoffset=buf.getcurrentoffset()
2332         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2333         self.__field_itemcount=UINT(**{'sizeinbytes': 4})
2334         self.__field_itemcount.readfrombuffer(buf)
2335         self.__field_items=LIST(**{ 'elementclass': textmemo })
2336         self.__field_items.readfrombuffer(buf)
2337         self._bufferendoffset=buf.getcurrentoffset()
2338 
2339 
2340     def __getfield_itemcount(self):
2341         return self.__field_itemcount.getvalue()
2342 
2343     def __setfield_itemcount(self, value):
2344         if isinstance(value,UINT):
2345             self.__field_itemcount=value
2346         else:
2347             self.__field_itemcount=UINT(value,**{'sizeinbytes': 4})
2348 
2349     def __delfield_itemcount(self): del self.__field_itemcount
2350 
2351     itemcount=property(__getfield_itemcount, __setfield_itemcount, __delfield_itemcount, None)
2352 
2353     def __getfield_items(self):
2354         try: self.__field_items
2355         except:
2356             self.__field_items=LIST(**{ 'elementclass': textmemo })
2357         return self.__field_items.getvalue()
2358 
2359     def __setfield_items(self, value):
2360         if isinstance(value,LIST):
2361             self.__field_items=value
2362         else:
2363             self.__field_items=LIST(value,**{ 'elementclass': textmemo })
2364 
2365     def __delfield_items(self): del self.__field_items
2366 
2367     items=property(__getfield_items, __setfield_items, __delfield_items, None)
2368 
2369     def iscontainer(self):
2370         return True
2371 
2372     def containerelements(self):
2373         yield ('itemcount', self.__field_itemcount, None)
2374         yield ('items', self.__field_items, None)
2375 
2376 
2377 
2378 
2379