PyXR

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

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