PyXR

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

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