PyXR

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

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