PyXR

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

0001 # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE
0002 
0003 """Various descriptions of data specific to LG LX5450"""
0004 
0005 from prototypes import *
0006 
0007 # Make all lg stuff available in this module as well
0008 from p_lg import *
0009 
0010 # we are the same as lgvx4400 except as noted
0011 # below
0012 from p_lgvx4400 import *
0013 
0014 # We use LSB for all integer like fields
0015 UINT=UINTlsb
0016 BOOL=BOOLlsb
0017 
0018 NUMSPEEDDIALS=100
0019 FIRSTSPEEDDIAL=2
0020 LASTSPEEDDIAL=99
0021 NUMPHONEBOOKENTRIES=500
0022 MAXCALENDARDESCRIPTION=38
0023 
0024 # Calendar parameters
0025 NUMCALENDARENTRIES=300
0026 CAL_REP_NONE=0x10
0027 CAL_REP_DAILY=0x11
0028 CAL_REP_MONFRI=0x12
0029 CAL_REP_WEEKLY=0x13
0030 CAL_REP_MONTHLY=0x14
0031 CAL_REP_YEARLY=0x15
0032 CAL_DOW_SUN=0x0800
0033 CAL_DOW_MON=0x0400
0034 CAL_DOW_TUE=0x0200
0035 CAL_DOW_WED=0x0100
0036 CAL_DOW_THU=0x0080
0037 CAL_DOW_FRI=0x0040
0038 CAL_DOW_SAT=0x0020
0039 CAL_DOW_EXCEPTIONS=0x0010
0040 CAL_REMINDER_NONE=0
0041 CAL_REMINDER_ONTIME=1
0042 CAL_REMINDER_5MIN=2
0043 CAL_REMINDER_10MIN=3
0044 CAL_REMINDER_1HOUR=4
0045 CAL_REMINDER_1DAY=5
0046 CAL_REMINDER_2DAYS=6
0047 CAL_REPEAT_DATE=(2100, 12, 31)
0048 
0049 cal_dir='sch'
0050 cal_data_file_name='sch/schedule.dat'
0051 cal_exception_file_name='sch/schexception.dat'
0052 cal_has_voice_id=False
0053 
0054 PHONE_ENCODING='iso8859_1'
0055 
0056 class speeddial(BaseProtogenClass):
0057     __fields=['entry', 'number']
0058 
0059     def __init__(self, *args, **kwargs):
0060         dict={}
0061         # What was supplied to this function
0062         dict.update(kwargs)
0063         # Parent constructor
0064         super(speeddial,self).__init__(**dict)
0065         if self.__class__ is speeddial:
0066             self._update(args,dict)
0067 
0068 
0069     def getfields(self):
0070         return self.__fields
0071 
0072 
0073     def _update(self, args, kwargs):
0074         super(speeddial,self)._update(args,kwargs)
0075         keys=kwargs.keys()
0076         for key in keys:
0077             if key in self.__fields:
0078                 setattr(self, key, kwargs[key])
0079                 del kwargs[key]
0080         # Were any unrecognized kwargs passed in?
0081         if __debug__:
0082             self._complainaboutunusedargs(speeddial,kwargs)
0083         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0084         # Make all P fields that haven't already been constructed
0085 
0086 
0087     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0088         'Writes this packet to the supplied buffer'
0089         self._bufferstartoffset=buf.getcurrentoffset()
0090         try: self.__field_entry
0091         except:
0092             self.__field_entry=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
0093         self.__field_entry.writetobuffer(buf)
0094         try: self.__field_number
0095         except:
0096             self.__field_number=UINT(**{'sizeinbytes': 1, 'default': 0xff})
0097         self.__field_number.writetobuffer(buf)
0098         self._bufferendoffset=buf.getcurrentoffset()
0099         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0100 
0101 
0102     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0103         'Reads this packet from the supplied buffer'
0104         self._bufferstartoffset=buf.getcurrentoffset()
0105         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0106         self.__field_entry=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
0107         self.__field_entry.readfrombuffer(buf)
0108         self.__field_number=UINT(**{'sizeinbytes': 1, 'default': 0xff})
0109         self.__field_number.readfrombuffer(buf)
0110         self._bufferendoffset=buf.getcurrentoffset()
0111 
0112 
0113     def __getfield_entry(self):
0114         try: self.__field_entry
0115         except:
0116             self.__field_entry=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
0117         return self.__field_entry.getvalue()
0118 
0119     def __setfield_entry(self, value):
0120         if isinstance(value,UINT):
0121             self.__field_entry=value
0122         else:
0123             self.__field_entry=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff})
0124 
0125     def __delfield_entry(self): del self.__field_entry
0126 
0127     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
0128 
0129     def __getfield_number(self):
0130         try: self.__field_number
0131         except:
0132             self.__field_number=UINT(**{'sizeinbytes': 1, 'default': 0xff})
0133         return self.__field_number.getvalue()
0134 
0135     def __setfield_number(self, value):
0136         if isinstance(value,UINT):
0137             self.__field_number=value
0138         else:
0139             self.__field_number=UINT(value,**{'sizeinbytes': 1, 'default': 0xff})
0140 
0141     def __delfield_number(self): del self.__field_number
0142 
0143     number=property(__getfield_number, __setfield_number, __delfield_number, None)
0144 
0145     def iscontainer(self):
0146         return True
0147 
0148     def containerelements(self):
0149         yield ('entry', self.__field_entry, None)
0150         yield ('number', self.__field_number, None)
0151 
0152 
0153 
0154 
0155 class speeddials(BaseProtogenClass):
0156     __fields=['speeddials']
0157 
0158     def __init__(self, *args, **kwargs):
0159         dict={}
0160         # What was supplied to this function
0161         dict.update(kwargs)
0162         # Parent constructor
0163         super(speeddials,self).__init__(**dict)
0164         if self.__class__ is speeddials:
0165             self._update(args,dict)
0166 
0167 
0168     def getfields(self):
0169         return self.__fields
0170 
0171 
0172     def _update(self, args, kwargs):
0173         super(speeddials,self)._update(args,kwargs)
0174         keys=kwargs.keys()
0175         for key in keys:
0176             if key in self.__fields:
0177                 setattr(self, key, kwargs[key])
0178                 del kwargs[key]
0179         # Were any unrecognized kwargs passed in?
0180         if __debug__:
0181             self._complainaboutunusedargs(speeddials,kwargs)
0182         if len(args):
0183             dict2={'length': NUMSPEEDDIALS, 'elementclass': speeddial}
0184             dict2.update(kwargs)
0185             kwargs=dict2
0186             self.__field_speeddials=LIST(*args,**dict2)
0187         # Make all P fields that haven't already been constructed
0188 
0189 
0190     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0191         'Writes this packet to the supplied buffer'
0192         self._bufferstartoffset=buf.getcurrentoffset()
0193         try: self.__field_speeddials
0194         except:
0195             self.__field_speeddials=LIST(**{'length': NUMSPEEDDIALS, 'elementclass': speeddial})
0196         self.__field_speeddials.writetobuffer(buf)
0197         self._bufferendoffset=buf.getcurrentoffset()
0198         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0199 
0200 
0201     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0202         'Reads this packet from the supplied buffer'
0203         self._bufferstartoffset=buf.getcurrentoffset()
0204         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0205         self.__field_speeddials=LIST(**{'length': NUMSPEEDDIALS, 'elementclass': speeddial})
0206         self.__field_speeddials.readfrombuffer(buf)
0207         self._bufferendoffset=buf.getcurrentoffset()
0208 
0209 
0210     def __getfield_speeddials(self):
0211         try: self.__field_speeddials
0212         except:
0213             self.__field_speeddials=LIST(**{'length': NUMSPEEDDIALS, 'elementclass': speeddial})
0214         return self.__field_speeddials.getvalue()
0215 
0216     def __setfield_speeddials(self, value):
0217         if isinstance(value,LIST):
0218             self.__field_speeddials=value
0219         else:
0220             self.__field_speeddials=LIST(value,**{'length': NUMSPEEDDIALS, 'elementclass': speeddial})
0221 
0222     def __delfield_speeddials(self): del self.__field_speeddials
0223 
0224     speeddials=property(__getfield_speeddials, __setfield_speeddials, __delfield_speeddials, None)
0225 
0226     def iscontainer(self):
0227         return True
0228 
0229     def containerelements(self):
0230         yield ('speeddials', self.__field_speeddials, None)
0231 
0232 
0233 
0234 
0235 class indexentry(BaseProtogenClass):
0236     __fields=['index', 'name']
0237 
0238     def __init__(self, *args, **kwargs):
0239         dict={}
0240         # What was supplied to this function
0241         dict.update(kwargs)
0242         # Parent constructor
0243         super(indexentry,self).__init__(**dict)
0244         if self.__class__ is indexentry:
0245             self._update(args,dict)
0246 
0247 
0248     def getfields(self):
0249         return self.__fields
0250 
0251 
0252     def _update(self, args, kwargs):
0253         super(indexentry,self)._update(args,kwargs)
0254         keys=kwargs.keys()
0255         for key in keys:
0256             if key in self.__fields:
0257                 setattr(self, key, kwargs[key])
0258                 del kwargs[key]
0259         # Were any unrecognized kwargs passed in?
0260         if __debug__:
0261             self._complainaboutunusedargs(indexentry,kwargs)
0262         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0263         # Make all P fields that haven't already been constructed
0264 
0265 
0266     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0267         'Writes this packet to the supplied buffer'
0268         self._bufferstartoffset=buf.getcurrentoffset()
0269         try: self.__field_index
0270         except:
0271             self.__field_index=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
0272         self.__field_index.writetobuffer(buf)
0273         try: self.__field_name
0274         except:
0275             self.__field_name=USTRING(**{'sizeinbytes': 50, 'default': ""})
0276         self.__field_name.writetobuffer(buf)
0277         self._bufferendoffset=buf.getcurrentoffset()
0278         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0279 
0280 
0281     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0282         'Reads this packet from the supplied buffer'
0283         self._bufferstartoffset=buf.getcurrentoffset()
0284         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0285         self.__field_index=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
0286         self.__field_index.readfrombuffer(buf)
0287         self.__field_name=USTRING(**{'sizeinbytes': 50, 'default': ""})
0288         self.__field_name.readfrombuffer(buf)
0289         self._bufferendoffset=buf.getcurrentoffset()
0290 
0291 
0292     def __getfield_index(self):
0293         try: self.__field_index
0294         except:
0295             self.__field_index=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
0296         return self.__field_index.getvalue()
0297 
0298     def __setfield_index(self, value):
0299         if isinstance(value,UINT):
0300             self.__field_index=value
0301         else:
0302             self.__field_index=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff})
0303 
0304     def __delfield_index(self): del self.__field_index
0305 
0306     index=property(__getfield_index, __setfield_index, __delfield_index, None)
0307 
0308     def __getfield_name(self):
0309         try: self.__field_name
0310         except:
0311             self.__field_name=USTRING(**{'sizeinbytes': 50, 'default': ""})
0312         return self.__field_name.getvalue()
0313 
0314     def __setfield_name(self, value):
0315         if isinstance(value,USTRING):
0316             self.__field_name=value
0317         else:
0318             self.__field_name=USTRING(value,**{'sizeinbytes': 50, 'default': ""})
0319 
0320     def __delfield_name(self): del self.__field_name
0321 
0322     name=property(__getfield_name, __setfield_name, __delfield_name, None)
0323 
0324     def iscontainer(self):
0325         return True
0326 
0327     def containerelements(self):
0328         yield ('index', self.__field_index, None)
0329         yield ('name', self.__field_name, None)
0330 
0331 
0332 
0333 
0334 class indexfile(BaseProtogenClass):
0335     "Used for tracking wallpaper and ringtones"
0336     __fields=['numactiveitems', 'items']
0337 
0338     def __init__(self, *args, **kwargs):
0339         dict={}
0340         # What was supplied to this function
0341         dict.update(kwargs)
0342         # Parent constructor
0343         super(indexfile,self).__init__(**dict)
0344         if self.__class__ is indexfile:
0345             self._update(args,dict)
0346 
0347 
0348     def getfields(self):
0349         return self.__fields
0350 
0351 
0352     def _update(self, args, kwargs):
0353         super(indexfile,self)._update(args,kwargs)
0354         keys=kwargs.keys()
0355         for key in keys:
0356             if key in self.__fields:
0357                 setattr(self, key, kwargs[key])
0358                 del kwargs[key]
0359         # Were any unrecognized kwargs passed in?
0360         if __debug__:
0361             self._complainaboutunusedargs(indexfile,kwargs)
0362         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0363         # Make all P fields that haven't already been constructed
0364 
0365 
0366     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0367         'Writes this packet to the supplied buffer'
0368         self._bufferstartoffset=buf.getcurrentoffset()
0369         self.__field_numactiveitems.writetobuffer(buf)
0370         try: self.__field_items
0371         except:
0372             self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True})
0373         self.__field_items.writetobuffer(buf)
0374         self._bufferendoffset=buf.getcurrentoffset()
0375         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0376 
0377 
0378     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0379         'Reads this packet from the supplied buffer'
0380         self._bufferstartoffset=buf.getcurrentoffset()
0381         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0382         self.__field_numactiveitems=UINT(**{'sizeinbytes': 2})
0383         self.__field_numactiveitems.readfrombuffer(buf)
0384         self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True})
0385         self.__field_items.readfrombuffer(buf)
0386         self._bufferendoffset=buf.getcurrentoffset()
0387 
0388 
0389     def __getfield_numactiveitems(self):
0390         return self.__field_numactiveitems.getvalue()
0391 
0392     def __setfield_numactiveitems(self, value):
0393         if isinstance(value,UINT):
0394             self.__field_numactiveitems=value
0395         else:
0396             self.__field_numactiveitems=UINT(value,**{'sizeinbytes': 2})
0397 
0398     def __delfield_numactiveitems(self): del self.__field_numactiveitems
0399 
0400     numactiveitems=property(__getfield_numactiveitems, __setfield_numactiveitems, __delfield_numactiveitems, None)
0401 
0402     def __getfield_items(self):
0403         try: self.__field_items
0404         except:
0405             self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True})
0406         return self.__field_items.getvalue()
0407 
0408     def __setfield_items(self, value):
0409         if isinstance(value,LIST):
0410             self.__field_items=value
0411         else:
0412             self.__field_items=LIST(value,**{'elementclass': indexentry, 'createdefault': True})
0413 
0414     def __delfield_items(self): del self.__field_items
0415 
0416     items=property(__getfield_items, __setfield_items, __delfield_items, None)
0417 
0418     def iscontainer(self):
0419         return True
0420 
0421     def containerelements(self):
0422         yield ('numactiveitems', self.__field_numactiveitems, None)
0423         yield ('items', self.__field_items, None)
0424 
0425 
0426 
0427 
0428 class camindexentry(BaseProtogenClass):
0429     __fields=['index', 'name', 'taken', 'dunno']
0430 
0431     def __init__(self, *args, **kwargs):
0432         dict={}
0433         # What was supplied to this function
0434         dict.update(kwargs)
0435         # Parent constructor
0436         super(camindexentry,self).__init__(**dict)
0437         if self.__class__ is camindexentry:
0438             self._update(args,dict)
0439 
0440 
0441     def getfields(self):
0442         return self.__fields
0443 
0444 
0445     def _update(self, args, kwargs):
0446         super(camindexentry,self)._update(args,kwargs)
0447         keys=kwargs.keys()
0448         for key in keys:
0449             if key in self.__fields:
0450                 setattr(self, key, kwargs[key])
0451                 del kwargs[key]
0452         # Were any unrecognized kwargs passed in?
0453         if __debug__:
0454             self._complainaboutunusedargs(camindexentry,kwargs)
0455         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0456         # Make all P fields that haven't already been constructed
0457 
0458 
0459     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0460         'Writes this packet to the supplied buffer'
0461         self._bufferstartoffset=buf.getcurrentoffset()
0462         try: self.__field_index
0463         except:
0464             self.__field_index=UINT(**{'sizeinbytes': 1, 'default': 0})
0465         self.__field_index.writetobuffer(buf)
0466         try: self.__field_name
0467         except:
0468             self.__field_name=USTRING(**{'sizeinbytes': 11, 'default': ""})
0469         self.__field_name.writetobuffer(buf)
0470         try: self.__field_taken
0471         except:
0472             self.__field_taken=LGCALDATE(**{'sizeinbytes': 4})
0473         self.__field_taken.writetobuffer(buf)
0474         try: self.__field_dunno
0475         except:
0476             self.__field_dunno=UINT(**{'sizeinbytes': 4, 'default': 0x00ff0100})
0477         self.__field_dunno.writetobuffer(buf)
0478         self._bufferendoffset=buf.getcurrentoffset()
0479         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0480 
0481 
0482     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0483         'Reads this packet from the supplied buffer'
0484         self._bufferstartoffset=buf.getcurrentoffset()
0485         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0486         self.__field_index=UINT(**{'sizeinbytes': 1, 'default': 0})
0487         self.__field_index.readfrombuffer(buf)
0488         self.__field_name=USTRING(**{'sizeinbytes': 11, 'default': ""})
0489         self.__field_name.readfrombuffer(buf)
0490         self.__field_taken=LGCALDATE(**{'sizeinbytes': 4})
0491         self.__field_taken.readfrombuffer(buf)
0492         self.__field_dunno=UINT(**{'sizeinbytes': 4, 'default': 0x00ff0100})
0493         self.__field_dunno.readfrombuffer(buf)
0494         self._bufferendoffset=buf.getcurrentoffset()
0495 
0496 
0497     def __getfield_index(self):
0498         try: self.__field_index
0499         except:
0500             self.__field_index=UINT(**{'sizeinbytes': 1, 'default': 0})
0501         return self.__field_index.getvalue()
0502 
0503     def __setfield_index(self, value):
0504         if isinstance(value,UINT):
0505             self.__field_index=value
0506         else:
0507             self.__field_index=UINT(value,**{'sizeinbytes': 1, 'default': 0})
0508 
0509     def __delfield_index(self): del self.__field_index
0510 
0511     index=property(__getfield_index, __setfield_index, __delfield_index, None)
0512 
0513     def __getfield_name(self):
0514         try: self.__field_name
0515         except:
0516             self.__field_name=USTRING(**{'sizeinbytes': 11, 'default': ""})
0517         return self.__field_name.getvalue()
0518 
0519     def __setfield_name(self, value):
0520         if isinstance(value,USTRING):
0521             self.__field_name=value
0522         else:
0523             self.__field_name=USTRING(value,**{'sizeinbytes': 11, 'default': ""})
0524 
0525     def __delfield_name(self): del self.__field_name
0526 
0527     name=property(__getfield_name, __setfield_name, __delfield_name, None)
0528 
0529     def __getfield_taken(self):
0530         try: self.__field_taken
0531         except:
0532             self.__field_taken=LGCALDATE(**{'sizeinbytes': 4})
0533         return self.__field_taken.getvalue()
0534 
0535     def __setfield_taken(self, value):
0536         if isinstance(value,LGCALDATE):
0537             self.__field_taken=value
0538         else:
0539             self.__field_taken=LGCALDATE(value,**{'sizeinbytes': 4})
0540 
0541     def __delfield_taken(self): del self.__field_taken
0542 
0543     taken=property(__getfield_taken, __setfield_taken, __delfield_taken, None)
0544 
0545     def __getfield_dunno(self):
0546         try: self.__field_dunno
0547         except:
0548             self.__field_dunno=UINT(**{'sizeinbytes': 4, 'default': 0x00ff0100})
0549         return self.__field_dunno.getvalue()
0550 
0551     def __setfield_dunno(self, value):
0552         if isinstance(value,UINT):
0553             self.__field_dunno=value
0554         else:
0555             self.__field_dunno=UINT(value,**{'sizeinbytes': 4, 'default': 0x00ff0100})
0556 
0557     def __delfield_dunno(self): del self.__field_dunno
0558 
0559     dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, None)
0560 
0561     def iscontainer(self):
0562         return True
0563 
0564     def containerelements(self):
0565         yield ('index', self.__field_index, None)
0566         yield ('name', self.__field_name, None)
0567         yield ('taken', self.__field_taken, None)
0568         yield ('dunno', self.__field_dunno, None)
0569 
0570 
0571 
0572 
0573 class campicsdat(BaseProtogenClass):
0574     "the cam/pics.dat file"
0575     __fields=['items']
0576 
0577     def __init__(self, *args, **kwargs):
0578         dict={}
0579         # What was supplied to this function
0580         dict.update(kwargs)
0581         # Parent constructor
0582         super(campicsdat,self).__init__(**dict)
0583         if self.__class__ is campicsdat:
0584             self._update(args,dict)
0585 
0586 
0587     def getfields(self):
0588         return self.__fields
0589 
0590 
0591     def _update(self, args, kwargs):
0592         super(campicsdat,self)._update(args,kwargs)
0593         keys=kwargs.keys()
0594         for key in keys:
0595             if key in self.__fields:
0596                 setattr(self, key, kwargs[key])
0597                 del kwargs[key]
0598         # Were any unrecognized kwargs passed in?
0599         if __debug__:
0600             self._complainaboutunusedargs(campicsdat,kwargs)
0601         if len(args):
0602             dict2={'length': 20, 'elementclass': camindexentry, 'createdefault': True}
0603             dict2.update(kwargs)
0604             kwargs=dict2
0605             self.__field_items=LIST(*args,**dict2)
0606         # Make all P fields that haven't already been constructed
0607 
0608 
0609     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0610         'Writes this packet to the supplied buffer'
0611         self._bufferstartoffset=buf.getcurrentoffset()
0612         try: self.__field_items
0613         except:
0614             self.__field_items=LIST(**{'length': 20, 'elementclass': camindexentry, 'createdefault': True})
0615         self.__field_items.writetobuffer(buf)
0616         self._bufferendoffset=buf.getcurrentoffset()
0617         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0618 
0619 
0620     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0621         'Reads this packet from the supplied buffer'
0622         self._bufferstartoffset=buf.getcurrentoffset()
0623         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0624         self.__field_items=LIST(**{'length': 20, 'elementclass': camindexentry, 'createdefault': True})
0625         self.__field_items.readfrombuffer(buf)
0626         self._bufferendoffset=buf.getcurrentoffset()
0627 
0628 
0629     def __getfield_items(self):
0630         try: self.__field_items
0631         except:
0632             self.__field_items=LIST(**{'length': 20, 'elementclass': camindexentry, 'createdefault': True})
0633         return self.__field_items.getvalue()
0634 
0635     def __setfield_items(self, value):
0636         if isinstance(value,LIST):
0637             self.__field_items=value
0638         else:
0639             self.__field_items=LIST(value,**{'length': 20, 'elementclass': camindexentry, 'createdefault': True})
0640 
0641     def __delfield_items(self): del self.__field_items
0642 
0643     items=property(__getfield_items, __setfield_items, __delfield_items, None)
0644 
0645     def iscontainer(self):
0646         return True
0647 
0648     def containerelements(self):
0649         yield ('items', self.__field_items, None)
0650 
0651 
0652 
0653 
0654 class scheduleexception(BaseProtogenClass):
0655     __fields=['pos', 'day', 'month', 'year']
0656 
0657     def __init__(self, *args, **kwargs):
0658         dict={}
0659         # What was supplied to this function
0660         dict.update(kwargs)
0661         # Parent constructor
0662         super(scheduleexception,self).__init__(**dict)
0663         if self.__class__ is scheduleexception:
0664             self._update(args,dict)
0665 
0666 
0667     def getfields(self):
0668         return self.__fields
0669 
0670 
0671     def _update(self, args, kwargs):
0672         super(scheduleexception,self)._update(args,kwargs)
0673         keys=kwargs.keys()
0674         for key in keys:
0675             if key in self.__fields:
0676                 setattr(self, key, kwargs[key])
0677                 del kwargs[key]
0678         # Were any unrecognized kwargs passed in?
0679         if __debug__:
0680             self._complainaboutunusedargs(scheduleexception,kwargs)
0681         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0682         # Make all P fields that haven't already been constructed
0683 
0684 
0685     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0686         'Writes this packet to the supplied buffer'
0687         self._bufferstartoffset=buf.getcurrentoffset()
0688         self.__field_pos.writetobuffer(buf)
0689         self.__field_day.writetobuffer(buf)
0690         self.__field_month.writetobuffer(buf)
0691         self.__field_year.writetobuffer(buf)
0692         self._bufferendoffset=buf.getcurrentoffset()
0693         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0694 
0695 
0696     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0697         'Reads this packet from the supplied buffer'
0698         self._bufferstartoffset=buf.getcurrentoffset()
0699         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0700         self.__field_pos=UINT(**{'sizeinbytes': 4})
0701         self.__field_pos.readfrombuffer(buf)
0702         self.__field_day=UINT(**{'sizeinbytes': 1})
0703         self.__field_day.readfrombuffer(buf)
0704         self.__field_month=UINT(**{'sizeinbytes': 1})
0705         self.__field_month.readfrombuffer(buf)
0706         self.__field_year=UINT(**{'sizeinbytes': 2})
0707         self.__field_year.readfrombuffer(buf)
0708         self._bufferendoffset=buf.getcurrentoffset()
0709 
0710 
0711     def __getfield_pos(self):
0712         return self.__field_pos.getvalue()
0713 
0714     def __setfield_pos(self, value):
0715         if isinstance(value,UINT):
0716             self.__field_pos=value
0717         else:
0718             self.__field_pos=UINT(value,**{'sizeinbytes': 4})
0719 
0720     def __delfield_pos(self): del self.__field_pos
0721 
0722     pos=property(__getfield_pos, __setfield_pos, __delfield_pos, "Refers to event id (position in schedule file) that this suppresses")
0723 
0724     def __getfield_day(self):
0725         return self.__field_day.getvalue()
0726 
0727     def __setfield_day(self, value):
0728         if isinstance(value,UINT):
0729             self.__field_day=value
0730         else:
0731             self.__field_day=UINT(value,**{'sizeinbytes': 1})
0732 
0733     def __delfield_day(self): del self.__field_day
0734 
0735     day=property(__getfield_day, __setfield_day, __delfield_day, None)
0736 
0737     def __getfield_month(self):
0738         return self.__field_month.getvalue()
0739 
0740     def __setfield_month(self, value):
0741         if isinstance(value,UINT):
0742             self.__field_month=value
0743         else:
0744             self.__field_month=UINT(value,**{'sizeinbytes': 1})
0745 
0746     def __delfield_month(self): del self.__field_month
0747 
0748     month=property(__getfield_month, __setfield_month, __delfield_month, None)
0749 
0750     def __getfield_year(self):
0751         return self.__field_year.getvalue()
0752 
0753     def __setfield_year(self, value):
0754         if isinstance(value,UINT):
0755             self.__field_year=value
0756         else:
0757             self.__field_year=UINT(value,**{'sizeinbytes': 2})
0758 
0759     def __delfield_year(self): del self.__field_year
0760 
0761     year=property(__getfield_year, __setfield_year, __delfield_year, None)
0762 
0763     def iscontainer(self):
0764         return True
0765 
0766     def containerelements(self):
0767         yield ('pos', self.__field_pos, "Refers to event id (position in schedule file) that this suppresses")
0768         yield ('day', self.__field_day, None)
0769         yield ('month', self.__field_month, None)
0770         yield ('year', self.__field_year, None)
0771 
0772 
0773 
0774 
0775 class scheduleexceptionfile(BaseProtogenClass):
0776     __fields=['items']
0777 
0778     def __init__(self, *args, **kwargs):
0779         dict={}
0780         # What was supplied to this function
0781         dict.update(kwargs)
0782         # Parent constructor
0783         super(scheduleexceptionfile,self).__init__(**dict)
0784         if self.__class__ is scheduleexceptionfile:
0785             self._update(args,dict)
0786 
0787 
0788     def getfields(self):
0789         return self.__fields
0790 
0791 
0792     def _update(self, args, kwargs):
0793         super(scheduleexceptionfile,self)._update(args,kwargs)
0794         keys=kwargs.keys()
0795         for key in keys:
0796             if key in self.__fields:
0797                 setattr(self, key, kwargs[key])
0798                 del kwargs[key]
0799         # Were any unrecognized kwargs passed in?
0800         if __debug__:
0801             self._complainaboutunusedargs(scheduleexceptionfile,kwargs)
0802         if len(args):
0803             dict2={'elementclass': scheduleexception}
0804             dict2.update(kwargs)
0805             kwargs=dict2
0806             self.__field_items=LIST(*args,**dict2)
0807         # Make all P fields that haven't already been constructed
0808 
0809 
0810     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0811         'Writes this packet to the supplied buffer'
0812         self._bufferstartoffset=buf.getcurrentoffset()
0813         try: self.__field_items
0814         except:
0815             self.__field_items=LIST(**{'elementclass': scheduleexception})
0816         self.__field_items.writetobuffer(buf)
0817         self._bufferendoffset=buf.getcurrentoffset()
0818         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0819 
0820 
0821     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0822         'Reads this packet from the supplied buffer'
0823         self._bufferstartoffset=buf.getcurrentoffset()
0824         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0825         self.__field_items=LIST(**{'elementclass': scheduleexception})
0826         self.__field_items.readfrombuffer(buf)
0827         self._bufferendoffset=buf.getcurrentoffset()
0828 
0829 
0830     def __getfield_items(self):
0831         try: self.__field_items
0832         except:
0833             self.__field_items=LIST(**{'elementclass': scheduleexception})
0834         return self.__field_items.getvalue()
0835 
0836     def __setfield_items(self, value):
0837         if isinstance(value,LIST):
0838             self.__field_items=value
0839         else:
0840             self.__field_items=LIST(value,**{'elementclass': scheduleexception})
0841 
0842     def __delfield_items(self): del self.__field_items
0843 
0844     items=property(__getfield_items, __setfield_items, __delfield_items, None)
0845 
0846     def iscontainer(self):
0847         return True
0848 
0849     def containerelements(self):
0850         yield ('items', self.__field_items, None)
0851 
0852 
0853 
0854 
0855 class scheduleevent(BaseProtogenClass):
0856     __fields=['packet_size', 'pos', 'start', 'end', 'repeat', 'daybitmap', 'pad2', 'alarmminutes', 'alarmhours', 'alarmtype', 'snoozedelay', 'ringtone', 'description']
0857 
0858     def __init__(self, *args, **kwargs):
0859         dict={}
0860         # What was supplied to this function
0861         dict.update(kwargs)
0862         # Parent constructor
0863         super(scheduleevent,self).__init__(**dict)
0864         if self.__class__ is scheduleevent:
0865             self._update(args,dict)
0866 
0867 
0868     def getfields(self):
0869         return self.__fields
0870 
0871 
0872     def _update(self, args, kwargs):
0873         super(scheduleevent,self)._update(args,kwargs)
0874         keys=kwargs.keys()
0875         for key in keys:
0876             if key in self.__fields:
0877                 setattr(self, key, kwargs[key])
0878                 del kwargs[key]
0879         # Were any unrecognized kwargs passed in?
0880         if __debug__:
0881             self._complainaboutunusedargs(scheduleevent,kwargs)
0882         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0883         # Make all P fields that haven't already been constructed
0884         try: self.__field_packet_size
0885         except:
0886             self.__field_packet_size=UINT(**{ 'constant': 60 })
0887 
0888 
0889     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0890         'Writes this packet to the supplied buffer'
0891         self._bufferstartoffset=buf.getcurrentoffset()
0892         self.__field_pos.writetobuffer(buf)
0893         self.__field_start.writetobuffer(buf)
0894         self.__field_end.writetobuffer(buf)
0895         self.__field_repeat.writetobuffer(buf)
0896         self.__field_daybitmap.writetobuffer(buf)
0897         try: self.__field_pad2
0898         except:
0899             self.__field_pad2=UINT(**{'sizeinbytes': 1,  'default': 0 })
0900         self.__field_pad2.writetobuffer(buf)
0901         self.__field_alarmminutes.writetobuffer(buf)
0902         self.__field_alarmhours.writetobuffer(buf)
0903         self.__field_alarmtype.writetobuffer(buf)
0904         try: self.__field_snoozedelay
0905         except:
0906             self.__field_snoozedelay=UINT(**{'sizeinbytes': 1,  'default': 0 })
0907         self.__field_snoozedelay.writetobuffer(buf)
0908         self.__field_ringtone.writetobuffer(buf)
0909         self.__field_description.writetobuffer(buf)
0910         self._bufferendoffset=buf.getcurrentoffset()
0911         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0912 
0913 
0914     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0915         'Reads this packet from the supplied buffer'
0916         self._bufferstartoffset=buf.getcurrentoffset()
0917         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0918         self.__field_pos=UINT(**{'sizeinbytes': 4})
0919         self.__field_pos.readfrombuffer(buf)
0920         self.__field_start=LGCALDATE(**{'sizeinbytes': 4})
0921         self.__field_start.readfrombuffer(buf)
0922         self.__field_end=LGCALDATE(**{'sizeinbytes': 4})
0923         self.__field_end.readfrombuffer(buf)
0924         self.__field_repeat=UINT(**{'sizeinbytes': 1})
0925         self.__field_repeat.readfrombuffer(buf)
0926         self.__field_daybitmap=UINT(**{'sizeinbytes': 2})
0927         self.__field_daybitmap.readfrombuffer(buf)
0928         self.__field_pad2=UINT(**{'sizeinbytes': 1,  'default': 0 })
0929         self.__field_pad2.readfrombuffer(buf)
0930         self.__field_alarmminutes=UINT(**{'sizeinbytes': 1})
0931         self.__field_alarmminutes.readfrombuffer(buf)
0932         self.__field_alarmhours=UINT(**{'sizeinbytes': 1})
0933         self.__field_alarmhours.readfrombuffer(buf)
0934         self.__field_alarmtype=UINT(**{'sizeinbytes': 1})
0935         self.__field_alarmtype.readfrombuffer(buf)
0936         self.__field_snoozedelay=UINT(**{'sizeinbytes': 1,  'default': 0 })
0937         self.__field_snoozedelay.readfrombuffer(buf)
0938         self.__field_ringtone=UINT(**{'sizeinbytes': 1})
0939         self.__field_ringtone.readfrombuffer(buf)
0940         self.__field_description=USTRING(**{'sizeinbytes': 39, 'encoding': PHONE_ENCODING, 'raiseontruncate': False,               'raiseonunterminatedread': False })
0941         self.__field_description.readfrombuffer(buf)
0942         self._bufferendoffset=buf.getcurrentoffset()
0943 
0944 
0945     def __getfield_packet_size(self):
0946         return self.__field_packet_size.getvalue()
0947 
0948     def __setfield_packet_size(self, value):
0949         if isinstance(value,UINT):
0950             self.__field_packet_size=value
0951         else:
0952             self.__field_packet_size=UINT(value,**{ 'constant': 60 })
0953 
0954     def __delfield_packet_size(self): del self.__field_packet_size
0955 
0956     packet_size=property(__getfield_packet_size, __setfield_packet_size, __delfield_packet_size, "Faster than packetsize()")
0957 
0958     def __getfield_pos(self):
0959         return self.__field_pos.getvalue()
0960 
0961     def __setfield_pos(self, value):
0962         if isinstance(value,UINT):
0963             self.__field_pos=value
0964         else:
0965             self.__field_pos=UINT(value,**{'sizeinbytes': 4})
0966 
0967     def __delfield_pos(self): del self.__field_pos
0968 
0969     pos=property(__getfield_pos, __setfield_pos, __delfield_pos, "position within file, used as an event id")
0970 
0971     def __getfield_start(self):
0972         return self.__field_start.getvalue()
0973 
0974     def __setfield_start(self, value):
0975         if isinstance(value,LGCALDATE):
0976             self.__field_start=value
0977         else:
0978             self.__field_start=LGCALDATE(value,**{'sizeinbytes': 4})
0979 
0980     def __delfield_start(self): del self.__field_start
0981 
0982     start=property(__getfield_start, __setfield_start, __delfield_start, None)
0983 
0984     def __getfield_end(self):
0985         return self.__field_end.getvalue()
0986 
0987     def __setfield_end(self, value):
0988         if isinstance(value,LGCALDATE):
0989             self.__field_end=value
0990         else:
0991             self.__field_end=LGCALDATE(value,**{'sizeinbytes': 4})
0992 
0993     def __delfield_end(self): del self.__field_end
0994 
0995     end=property(__getfield_end, __setfield_end, __delfield_end, None)
0996 
0997     def __getfield_repeat(self):
0998         return self.__field_repeat.getvalue()
0999 
1000     def __setfield_repeat(self, value):
1001         if isinstance(value,UINT):
1002             self.__field_repeat=value
1003         else:
1004             self.__field_repeat=UINT(value,**{'sizeinbytes': 1})
1005 
1006     def __delfield_repeat(self): del self.__field_repeat
1007 
1008     repeat=property(__getfield_repeat, __setfield_repeat, __delfield_repeat, None)
1009 
1010     def __getfield_daybitmap(self):
1011         return self.__field_daybitmap.getvalue()
1012 
1013     def __setfield_daybitmap(self, value):
1014         if isinstance(value,UINT):
1015             self.__field_daybitmap=value
1016         else:
1017             self.__field_daybitmap=UINT(value,**{'sizeinbytes': 2})
1018 
1019     def __delfield_daybitmap(self): del self.__field_daybitmap
1020 
1021     daybitmap=property(__getfield_daybitmap, __setfield_daybitmap, __delfield_daybitmap, "which days a weekly repeat event happens on")
1022 
1023     def __getfield_pad2(self):
1024         try: self.__field_pad2
1025         except:
1026             self.__field_pad2=UINT(**{'sizeinbytes': 1,  'default': 0 })
1027         return self.__field_pad2.getvalue()
1028 
1029     def __setfield_pad2(self, value):
1030         if isinstance(value,UINT):
1031             self.__field_pad2=value
1032         else:
1033             self.__field_pad2=UINT(value,**{'sizeinbytes': 1,  'default': 0 })
1034 
1035     def __delfield_pad2(self): del self.__field_pad2
1036 
1037     pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None)
1038 
1039     def __getfield_alarmminutes(self):
1040         return self.__field_alarmminutes.getvalue()
1041 
1042     def __setfield_alarmminutes(self, value):
1043         if isinstance(value,UINT):
1044             self.__field_alarmminutes=value
1045         else:
1046             self.__field_alarmminutes=UINT(value,**{'sizeinbytes': 1})
1047 
1048     def __delfield_alarmminutes(self): del self.__field_alarmminutes
1049 
1050     alarmminutes=property(__getfield_alarmminutes, __setfield_alarmminutes, __delfield_alarmminutes, "a value of 100 indicates not set")
1051 
1052     def __getfield_alarmhours(self):
1053         return self.__field_alarmhours.getvalue()
1054 
1055     def __setfield_alarmhours(self, value):
1056         if isinstance(value,UINT):
1057             self.__field_alarmhours=value
1058         else:
1059             self.__field_alarmhours=UINT(value,**{'sizeinbytes': 1})
1060 
1061     def __delfield_alarmhours(self): del self.__field_alarmhours
1062 
1063     alarmhours=property(__getfield_alarmhours, __setfield_alarmhours, __delfield_alarmhours, "a value of 100 indicates not set")
1064 
1065     def __getfield_alarmtype(self):
1066         return self.__field_alarmtype.getvalue()
1067 
1068     def __setfield_alarmtype(self, value):
1069         if isinstance(value,UINT):
1070             self.__field_alarmtype=value
1071         else:
1072             self.__field_alarmtype=UINT(value,**{'sizeinbytes': 1})
1073 
1074     def __delfield_alarmtype(self): del self.__field_alarmtype
1075 
1076     alarmtype=property(__getfield_alarmtype, __setfield_alarmtype, __delfield_alarmtype, "preset alarm reminder type")
1077 
1078     def __getfield_snoozedelay(self):
1079         try: self.__field_snoozedelay
1080         except:
1081             self.__field_snoozedelay=UINT(**{'sizeinbytes': 1,  'default': 0 })
1082         return self.__field_snoozedelay.getvalue()
1083 
1084     def __setfield_snoozedelay(self, value):
1085         if isinstance(value,UINT):
1086             self.__field_snoozedelay=value
1087         else:
1088             self.__field_snoozedelay=UINT(value,**{'sizeinbytes': 1,  'default': 0 })
1089 
1090     def __delfield_snoozedelay(self): del self.__field_snoozedelay
1091 
1092     snoozedelay=property(__getfield_snoozedelay, __setfield_snoozedelay, __delfield_snoozedelay, "in minutes, not for this phone")
1093 
1094     def __getfield_ringtone(self):
1095         return self.__field_ringtone.getvalue()
1096 
1097     def __setfield_ringtone(self, value):
1098         if isinstance(value,UINT):
1099             self.__field_ringtone=value
1100         else:
1101             self.__field_ringtone=UINT(value,**{'sizeinbytes': 1})
1102 
1103     def __delfield_ringtone(self): del self.__field_ringtone
1104 
1105     ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None)
1106 
1107     def __getfield_description(self):
1108         return self.__field_description.getvalue()
1109 
1110     def __setfield_description(self, value):
1111         if isinstance(value,USTRING):
1112             self.__field_description=value
1113         else:
1114             self.__field_description=USTRING(value,**{'sizeinbytes': 39, 'encoding': PHONE_ENCODING, 'raiseontruncate': False,               'raiseonunterminatedread': False })
1115 
1116     def __delfield_description(self): del self.__field_description
1117 
1118     description=property(__getfield_description, __setfield_description, __delfield_description, None)
1119 
1120     def iscontainer(self):
1121         return True
1122 
1123     def containerelements(self):
1124         yield ('packet_size', self.__field_packet_size, "Faster than packetsize()")
1125         yield ('pos', self.__field_pos, "position within file, used as an event id")
1126         yield ('start', self.__field_start, None)
1127         yield ('end', self.__field_end, None)
1128         yield ('repeat', self.__field_repeat, None)
1129         yield ('daybitmap', self.__field_daybitmap, "which days a weekly repeat event happens on")
1130         yield ('pad2', self.__field_pad2, None)
1131         yield ('alarmminutes', self.__field_alarmminutes, "a value of 100 indicates not set")
1132         yield ('alarmhours', self.__field_alarmhours, "a value of 100 indicates not set")
1133         yield ('alarmtype', self.__field_alarmtype, "preset alarm reminder type")
1134         yield ('snoozedelay', self.__field_snoozedelay, "in minutes, not for this phone")
1135         yield ('ringtone', self.__field_ringtone, None)
1136         yield ('description', self.__field_description, None)
1137 
1138 
1139 
1140 
1141 class schedulefile(BaseProtogenClass):
1142     __fields=['numactiveitems', 'events']
1143 
1144     def __init__(self, *args, **kwargs):
1145         dict={}
1146         # What was supplied to this function
1147         dict.update(kwargs)
1148         # Parent constructor
1149         super(schedulefile,self).__init__(**dict)
1150         if self.__class__ is schedulefile:
1151             self._update(args,dict)
1152 
1153 
1154     def getfields(self):
1155         return self.__fields
1156 
1157 
1158     def _update(self, args, kwargs):
1159         super(schedulefile,self)._update(args,kwargs)
1160         keys=kwargs.keys()
1161         for key in keys:
1162             if key in self.__fields:
1163                 setattr(self, key, kwargs[key])
1164                 del kwargs[key]
1165         # Were any unrecognized kwargs passed in?
1166         if __debug__:
1167             self._complainaboutunusedargs(schedulefile,kwargs)
1168         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1169         # Make all P fields that haven't already been constructed
1170 
1171 
1172     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1173         'Writes this packet to the supplied buffer'
1174         self._bufferstartoffset=buf.getcurrentoffset()
1175         self.__field_numactiveitems.writetobuffer(buf)
1176         try: self.__field_events
1177         except:
1178             self.__field_events=LIST(**{'elementclass': scheduleevent})
1179         self.__field_events.writetobuffer(buf)
1180         self._bufferendoffset=buf.getcurrentoffset()
1181         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1182 
1183 
1184     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1185         'Reads this packet from the supplied buffer'
1186         self._bufferstartoffset=buf.getcurrentoffset()
1187         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1188         self.__field_numactiveitems=UINT(**{'sizeinbytes': 2})
1189         self.__field_numactiveitems.readfrombuffer(buf)
1190         self.__field_events=LIST(**{'elementclass': scheduleevent})
1191         self.__field_events.readfrombuffer(buf)
1192         self._bufferendoffset=buf.getcurrentoffset()
1193 
1194 
1195     def __getfield_numactiveitems(self):
1196         return self.__field_numactiveitems.getvalue()
1197 
1198     def __setfield_numactiveitems(self, value):
1199         if isinstance(value,UINT):
1200             self.__field_numactiveitems=value
1201         else:
1202             self.__field_numactiveitems=UINT(value,**{'sizeinbytes': 2})
1203 
1204     def __delfield_numactiveitems(self): del self.__field_numactiveitems
1205 
1206     numactiveitems=property(__getfield_numactiveitems, __setfield_numactiveitems, __delfield_numactiveitems, None)
1207 
1208     def __getfield_events(self):
1209         try: self.__field_events
1210         except:
1211             self.__field_events=LIST(**{'elementclass': scheduleevent})
1212         return self.__field_events.getvalue()
1213 
1214     def __setfield_events(self, value):
1215         if isinstance(value,LIST):
1216             self.__field_events=value
1217         else:
1218             self.__field_events=LIST(value,**{'elementclass': scheduleevent})
1219 
1220     def __delfield_events(self): del self.__field_events
1221 
1222     events=property(__getfield_events, __setfield_events, __delfield_events, None)
1223 
1224     def iscontainer(self):
1225         return True
1226 
1227     def containerelements(self):
1228         yield ('numactiveitems', self.__field_numactiveitems, None)
1229         yield ('events', self.__field_events, None)
1230 
1231 
1232 
1233 
1234 class call(BaseProtogenClass):
1235     __fields=['GPStime', 'unknown1', 'duration', 'number', 'name', 'numberlength', 'unknown2', 'pbnumbertype', 'unknown3', 'pbentrynum']
1236 
1237     def __init__(self, *args, **kwargs):
1238         dict={}
1239         # What was supplied to this function
1240         dict.update(kwargs)
1241         # Parent constructor
1242         super(call,self).__init__(**dict)
1243         if self.__class__ is call:
1244             self._update(args,dict)
1245 
1246 
1247     def getfields(self):
1248         return self.__fields
1249 
1250 
1251     def _update(self, args, kwargs):
1252         super(call,self)._update(args,kwargs)
1253         keys=kwargs.keys()
1254         for key in keys:
1255             if key in self.__fields:
1256                 setattr(self, key, kwargs[key])
1257                 del kwargs[key]
1258         # Were any unrecognized kwargs passed in?
1259         if __debug__:
1260             self._complainaboutunusedargs(call,kwargs)
1261         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1262         # Make all P fields that haven't already been constructed
1263 
1264 
1265     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1266         'Writes this packet to the supplied buffer'
1267         self._bufferstartoffset=buf.getcurrentoffset()
1268         self.__field_GPStime.writetobuffer(buf)
1269         self.__field_unknown1.writetobuffer(buf)
1270         self.__field_duration.writetobuffer(buf)
1271         self.__field_number.writetobuffer(buf)
1272         self.__field_name.writetobuffer(buf)
1273         self.__field_numberlength.writetobuffer(buf)
1274         self.__field_unknown2.writetobuffer(buf)
1275         self.__field_pbnumbertype.writetobuffer(buf)
1276         self.__field_unknown3.writetobuffer(buf)
1277         self.__field_pbentrynum.writetobuffer(buf)
1278         self._bufferendoffset=buf.getcurrentoffset()
1279         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1280 
1281 
1282     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1283         'Reads this packet from the supplied buffer'
1284         self._bufferstartoffset=buf.getcurrentoffset()
1285         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1286         self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4})
1287         self.__field_GPStime.readfrombuffer(buf)
1288         self.__field_unknown1=UINT(**{'sizeinbytes': 4})
1289         self.__field_unknown1.readfrombuffer(buf)
1290         self.__field_duration=UINT(**{'sizeinbytes': 4})
1291         self.__field_duration.readfrombuffer(buf)
1292         self.__field_number=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
1293         self.__field_number.readfrombuffer(buf)
1294         self.__field_name=USTRING(**{'sizeinbytes': 36, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
1295         self.__field_name.readfrombuffer(buf)
1296         self.__field_numberlength=UINT(**{'sizeinbytes': 1})
1297         self.__field_numberlength.readfrombuffer(buf)
1298         self.__field_unknown2=UINT(**{'sizeinbytes': 1})
1299         self.__field_unknown2.readfrombuffer(buf)
1300         self.__field_pbnumbertype=UINT(**{'sizeinbytes': 1})
1301         self.__field_pbnumbertype.readfrombuffer(buf)
1302         self.__field_unknown3=UINT(**{'sizeinbytes': 2})
1303         self.__field_unknown3.readfrombuffer(buf)
1304         self.__field_pbentrynum=UINT(**{'sizeinbytes': 2})
1305         self.__field_pbentrynum.readfrombuffer(buf)
1306         self._bufferendoffset=buf.getcurrentoffset()
1307 
1308 
1309     def __getfield_GPStime(self):
1310         return self.__field_GPStime.getvalue()
1311 
1312     def __setfield_GPStime(self, value):
1313         if isinstance(value,GPSDATE):
1314             self.__field_GPStime=value
1315         else:
1316             self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4})
1317 
1318     def __delfield_GPStime(self): del self.__field_GPStime
1319 
1320     GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None)
1321 
1322     def __getfield_unknown1(self):
1323         return self.__field_unknown1.getvalue()
1324 
1325     def __setfield_unknown1(self, value):
1326         if isinstance(value,UINT):
1327             self.__field_unknown1=value
1328         else:
1329             self.__field_unknown1=UINT(value,**{'sizeinbytes': 4})
1330 
1331     def __delfield_unknown1(self): del self.__field_unknown1
1332 
1333     unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None)
1334 
1335     def __getfield_duration(self):
1336         return self.__field_duration.getvalue()
1337 
1338     def __setfield_duration(self, value):
1339         if isinstance(value,UINT):
1340             self.__field_duration=value
1341         else:
1342             self.__field_duration=UINT(value,**{'sizeinbytes': 4})
1343 
1344     def __delfield_duration(self): del self.__field_duration
1345 
1346     duration=property(__getfield_duration, __setfield_duration, __delfield_duration, None)
1347 
1348     def __getfield_number(self):
1349         return self.__field_number.getvalue()
1350 
1351     def __setfield_number(self, value):
1352         if isinstance(value,USTRING):
1353             self.__field_number=value
1354         else:
1355             self.__field_number=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
1356 
1357     def __delfield_number(self): del self.__field_number
1358 
1359     number=property(__getfield_number, __setfield_number, __delfield_number, None)
1360 
1361     def __getfield_name(self):
1362         return self.__field_name.getvalue()
1363 
1364     def __setfield_name(self, value):
1365         if isinstance(value,USTRING):
1366             self.__field_name=value
1367         else:
1368             self.__field_name=USTRING(value,**{'sizeinbytes': 36, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
1369 
1370     def __delfield_name(self): del self.__field_name
1371 
1372     name=property(__getfield_name, __setfield_name, __delfield_name, None)
1373 
1374     def __getfield_numberlength(self):
1375         return self.__field_numberlength.getvalue()
1376 
1377     def __setfield_numberlength(self, value):
1378         if isinstance(value,UINT):
1379             self.__field_numberlength=value
1380         else:
1381             self.__field_numberlength=UINT(value,**{'sizeinbytes': 1})
1382 
1383     def __delfield_numberlength(self): del self.__field_numberlength
1384 
1385     numberlength=property(__getfield_numberlength, __setfield_numberlength, __delfield_numberlength, None)
1386 
1387     def __getfield_unknown2(self):
1388         return self.__field_unknown2.getvalue()
1389 
1390     def __setfield_unknown2(self, value):
1391         if isinstance(value,UINT):
1392             self.__field_unknown2=value
1393         else:
1394             self.__field_unknown2=UINT(value,**{'sizeinbytes': 1})
1395 
1396     def __delfield_unknown2(self): del self.__field_unknown2
1397 
1398     unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None)
1399 
1400     def __getfield_pbnumbertype(self):
1401         return self.__field_pbnumbertype.getvalue()
1402 
1403     def __setfield_pbnumbertype(self, value):
1404         if isinstance(value,UINT):
1405             self.__field_pbnumbertype=value
1406         else:
1407             self.__field_pbnumbertype=UINT(value,**{'sizeinbytes': 1})
1408 
1409     def __delfield_pbnumbertype(self): del self.__field_pbnumbertype
1410 
1411     pbnumbertype=property(__getfield_pbnumbertype, __setfield_pbnumbertype, __delfield_pbnumbertype, None)
1412 
1413     def __getfield_unknown3(self):
1414         return self.__field_unknown3.getvalue()
1415 
1416     def __setfield_unknown3(self, value):
1417         if isinstance(value,UINT):
1418             self.__field_unknown3=value
1419         else:
1420             self.__field_unknown3=UINT(value,**{'sizeinbytes': 2})
1421 
1422     def __delfield_unknown3(self): del self.__field_unknown3
1423 
1424     unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None)
1425 
1426     def __getfield_pbentrynum(self):
1427         return self.__field_pbentrynum.getvalue()
1428 
1429     def __setfield_pbentrynum(self, value):
1430         if isinstance(value,UINT):
1431             self.__field_pbentrynum=value
1432         else:
1433             self.__field_pbentrynum=UINT(value,**{'sizeinbytes': 2})
1434 
1435     def __delfield_pbentrynum(self): del self.__field_pbentrynum
1436 
1437     pbentrynum=property(__getfield_pbentrynum, __setfield_pbentrynum, __delfield_pbentrynum, None)
1438 
1439     def iscontainer(self):
1440         return True
1441 
1442     def containerelements(self):
1443         yield ('GPStime', self.__field_GPStime, None)
1444         yield ('unknown1', self.__field_unknown1, None)
1445         yield ('duration', self.__field_duration, None)
1446         yield ('number', self.__field_number, None)
1447         yield ('name', self.__field_name, None)
1448         yield ('numberlength', self.__field_numberlength, None)
1449         yield ('unknown2', self.__field_unknown2, None)
1450         yield ('pbnumbertype', self.__field_pbnumbertype, None)
1451         yield ('unknown3', self.__field_unknown3, None)
1452         yield ('pbentrynum', self.__field_pbentrynum, None)
1453 
1454 
1455 
1456 
1457 class callhistory(BaseProtogenClass):
1458     __fields=['numcalls', 'unknown1', 'calls']
1459 
1460     def __init__(self, *args, **kwargs):
1461         dict={}
1462         # What was supplied to this function
1463         dict.update(kwargs)
1464         # Parent constructor
1465         super(callhistory,self).__init__(**dict)
1466         if self.__class__ is callhistory:
1467             self._update(args,dict)
1468 
1469 
1470     def getfields(self):
1471         return self.__fields
1472 
1473 
1474     def _update(self, args, kwargs):
1475         super(callhistory,self)._update(args,kwargs)
1476         keys=kwargs.keys()
1477         for key in keys:
1478             if key in self.__fields:
1479                 setattr(self, key, kwargs[key])
1480                 del kwargs[key]
1481         # Were any unrecognized kwargs passed in?
1482         if __debug__:
1483             self._complainaboutunusedargs(callhistory,kwargs)
1484         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1485         # Make all P fields that haven't already been constructed
1486 
1487 
1488     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1489         'Writes this packet to the supplied buffer'
1490         self._bufferstartoffset=buf.getcurrentoffset()
1491         self.__field_numcalls.writetobuffer(buf)
1492         self.__field_unknown1.writetobuffer(buf)
1493         try: self.__field_calls
1494         except:
1495             self.__field_calls=LIST(**{'elementclass': call})
1496         self.__field_calls.writetobuffer(buf)
1497         self._bufferendoffset=buf.getcurrentoffset()
1498         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1499 
1500 
1501     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1502         'Reads this packet from the supplied buffer'
1503         self._bufferstartoffset=buf.getcurrentoffset()
1504         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1505         self.__field_numcalls=UINT(**{'sizeinbytes': 4})
1506         self.__field_numcalls.readfrombuffer(buf)
1507         self.__field_unknown1=UINT(**{'sizeinbytes': 1})
1508         self.__field_unknown1.readfrombuffer(buf)
1509         self.__field_calls=LIST(**{'elementclass': call})
1510         self.__field_calls.readfrombuffer(buf)
1511         self._bufferendoffset=buf.getcurrentoffset()
1512 
1513 
1514     def __getfield_numcalls(self):
1515         return self.__field_numcalls.getvalue()
1516 
1517     def __setfield_numcalls(self, value):
1518         if isinstance(value,UINT):
1519             self.__field_numcalls=value
1520         else:
1521             self.__field_numcalls=UINT(value,**{'sizeinbytes': 4})
1522 
1523     def __delfield_numcalls(self): del self.__field_numcalls
1524 
1525     numcalls=property(__getfield_numcalls, __setfield_numcalls, __delfield_numcalls, None)
1526 
1527     def __getfield_unknown1(self):
1528         return self.__field_unknown1.getvalue()
1529 
1530     def __setfield_unknown1(self, value):
1531         if isinstance(value,UINT):
1532             self.__field_unknown1=value
1533         else:
1534             self.__field_unknown1=UINT(value,**{'sizeinbytes': 1})
1535 
1536     def __delfield_unknown1(self): del self.__field_unknown1
1537 
1538     unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None)
1539 
1540     def __getfield_calls(self):
1541         try: self.__field_calls
1542         except:
1543             self.__field_calls=LIST(**{'elementclass': call})
1544         return self.__field_calls.getvalue()
1545 
1546     def __setfield_calls(self, value):
1547         if isinstance(value,LIST):
1548             self.__field_calls=value
1549         else:
1550             self.__field_calls=LIST(value,**{'elementclass': call})
1551 
1552     def __delfield_calls(self): del self.__field_calls
1553 
1554     calls=property(__getfield_calls, __setfield_calls, __delfield_calls, None)
1555 
1556     def iscontainer(self):
1557         return True
1558 
1559     def containerelements(self):
1560         yield ('numcalls', self.__field_numcalls, None)
1561         yield ('unknown1', self.__field_unknown1, None)
1562         yield ('calls', self.__field_calls, None)
1563 
1564 
1565 
1566 
1567 class msg_record(BaseProtogenClass):
1568     __fields=['unknown1', 'binary', 'unknown3', 'unknown4', 'unknown6', 'length', 'msg']
1569 
1570     def __init__(self, *args, **kwargs):
1571         dict={}
1572         # What was supplied to this function
1573         dict.update(kwargs)
1574         # Parent constructor
1575         super(msg_record,self).__init__(**dict)
1576         if self.__class__ is msg_record:
1577             self._update(args,dict)
1578 
1579 
1580     def getfields(self):
1581         return self.__fields
1582 
1583 
1584     def _update(self, args, kwargs):
1585         super(msg_record,self)._update(args,kwargs)
1586         keys=kwargs.keys()
1587         for key in keys:
1588             if key in self.__fields:
1589                 setattr(self, key, kwargs[key])
1590                 del kwargs[key]
1591         # Were any unrecognized kwargs passed in?
1592         if __debug__:
1593             self._complainaboutunusedargs(msg_record,kwargs)
1594         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1595         # Make all P fields that haven't already been constructed
1596 
1597 
1598     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1599         'Writes this packet to the supplied buffer'
1600         self._bufferstartoffset=buf.getcurrentoffset()
1601         self.__field_unknown1.writetobuffer(buf)
1602         self.__field_binary.writetobuffer(buf)
1603         self.__field_unknown3.writetobuffer(buf)
1604         self.__field_unknown4.writetobuffer(buf)
1605         self.__field_unknown6.writetobuffer(buf)
1606         self.__field_length.writetobuffer(buf)
1607         try: self.__field_msg
1608         except:
1609             self.__field_msg=LIST(**{'elementclass': _gen_p_lglx5450_186, 'length': 219})
1610         self.__field_msg.writetobuffer(buf)
1611         self._bufferendoffset=buf.getcurrentoffset()
1612         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1613 
1614 
1615     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1616         'Reads this packet from the supplied buffer'
1617         self._bufferstartoffset=buf.getcurrentoffset()
1618         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1619         self.__field_unknown1=UINT(**{'sizeinbytes': 1})
1620         self.__field_unknown1.readfrombuffer(buf)
1621         self.__field_binary=UINT(**{'sizeinbytes': 1})
1622         self.__field_binary.readfrombuffer(buf)
1623         self.__field_unknown3=UINT(**{'sizeinbytes': 1})
1624         self.__field_unknown3.readfrombuffer(buf)
1625         self.__field_unknown4=UINT(**{'sizeinbytes': 1})
1626         self.__field_unknown4.readfrombuffer(buf)
1627         self.__field_unknown6=UINT(**{'sizeinbytes': 1})
1628         self.__field_unknown6.readfrombuffer(buf)
1629         self.__field_length=UINT(**{'sizeinbytes': 1})
1630         self.__field_length.readfrombuffer(buf)
1631         self.__field_msg=LIST(**{'elementclass': _gen_p_lglx5450_186, 'length': 219})
1632         self.__field_msg.readfrombuffer(buf)
1633         self._bufferendoffset=buf.getcurrentoffset()
1634 
1635 
1636     def __getfield_unknown1(self):
1637         return self.__field_unknown1.getvalue()
1638 
1639     def __setfield_unknown1(self, value):
1640         if isinstance(value,UINT):
1641             self.__field_unknown1=value
1642         else:
1643             self.__field_unknown1=UINT(value,**{'sizeinbytes': 1})
1644 
1645     def __delfield_unknown1(self): del self.__field_unknown1
1646 
1647     unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None)
1648 
1649     def __getfield_binary(self):
1650         return self.__field_binary.getvalue()
1651 
1652     def __setfield_binary(self, value):
1653         if isinstance(value,UINT):
1654             self.__field_binary=value
1655         else:
1656             self.__field_binary=UINT(value,**{'sizeinbytes': 1})
1657 
1658     def __delfield_binary(self): del self.__field_binary
1659 
1660     binary=property(__getfield_binary, __setfield_binary, __delfield_binary, None)
1661 
1662     def __getfield_unknown3(self):
1663         return self.__field_unknown3.getvalue()
1664 
1665     def __setfield_unknown3(self, value):
1666         if isinstance(value,UINT):
1667             self.__field_unknown3=value
1668         else:
1669             self.__field_unknown3=UINT(value,**{'sizeinbytes': 1})
1670 
1671     def __delfield_unknown3(self): del self.__field_unknown3
1672 
1673     unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None)
1674 
1675     def __getfield_unknown4(self):
1676         return self.__field_unknown4.getvalue()
1677 
1678     def __setfield_unknown4(self, value):
1679         if isinstance(value,UINT):
1680             self.__field_unknown4=value
1681         else:
1682             self.__field_unknown4=UINT(value,**{'sizeinbytes': 1})
1683 
1684     def __delfield_unknown4(self): del self.__field_unknown4
1685 
1686     unknown4=property(__getfield_unknown4, __setfield_unknown4, __delfield_unknown4, None)
1687 
1688     def __getfield_unknown6(self):
1689         return self.__field_unknown6.getvalue()
1690 
1691     def __setfield_unknown6(self, value):
1692         if isinstance(value,UINT):
1693             self.__field_unknown6=value
1694         else:
1695             self.__field_unknown6=UINT(value,**{'sizeinbytes': 1})
1696 
1697     def __delfield_unknown6(self): del self.__field_unknown6
1698 
1699     unknown6=property(__getfield_unknown6, __setfield_unknown6, __delfield_unknown6, None)
1700 
1701     def __getfield_length(self):
1702         return self.__field_length.getvalue()
1703 
1704     def __setfield_length(self, value):
1705         if isinstance(value,UINT):
1706             self.__field_length=value
1707         else:
1708             self.__field_length=UINT(value,**{'sizeinbytes': 1})
1709 
1710     def __delfield_length(self): del self.__field_length
1711 
1712     length=property(__getfield_length, __setfield_length, __delfield_length, None)
1713 
1714     def __getfield_msg(self):
1715         try: self.__field_msg
1716         except:
1717             self.__field_msg=LIST(**{'elementclass': _gen_p_lglx5450_186, 'length': 219})
1718         return self.__field_msg.getvalue()
1719 
1720     def __setfield_msg(self, value):
1721         if isinstance(value,LIST):
1722             self.__field_msg=value
1723         else:
1724             self.__field_msg=LIST(value,**{'elementclass': _gen_p_lglx5450_186, 'length': 219})
1725 
1726     def __delfield_msg(self): del self.__field_msg
1727 
1728     msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None)
1729 
1730     def iscontainer(self):
1731         return True
1732 
1733     def containerelements(self):
1734         yield ('unknown1', self.__field_unknown1, None)
1735         yield ('binary', self.__field_binary, None)
1736         yield ('unknown3', self.__field_unknown3, None)
1737         yield ('unknown4', self.__field_unknown4, None)
1738         yield ('unknown6', self.__field_unknown6, None)
1739         yield ('length', self.__field_length, None)
1740         yield ('msg', self.__field_msg, None)
1741 
1742 
1743 
1744 
1745 class _gen_p_lglx5450_186(BaseProtogenClass):
1746     'Anonymous inner class'
1747     __fields=['byte']
1748 
1749     def __init__(self, *args, **kwargs):
1750         dict={}
1751         # What was supplied to this function
1752         dict.update(kwargs)
1753         # Parent constructor
1754         super(_gen_p_lglx5450_186,self).__init__(**dict)
1755         if self.__class__ is _gen_p_lglx5450_186:
1756             self._update(args,dict)
1757 
1758 
1759     def getfields(self):
1760         return self.__fields
1761 
1762 
1763     def _update(self, args, kwargs):
1764         super(_gen_p_lglx5450_186,self)._update(args,kwargs)
1765         keys=kwargs.keys()
1766         for key in keys:
1767             if key in self.__fields:
1768                 setattr(self, key, kwargs[key])
1769                 del kwargs[key]
1770         # Were any unrecognized kwargs passed in?
1771         if __debug__:
1772             self._complainaboutunusedargs(_gen_p_lglx5450_186,kwargs)
1773         if len(args):
1774             dict2={'sizeinbytes': 1}
1775             dict2.update(kwargs)
1776             kwargs=dict2
1777             self.__field_byte=UINT(*args,**dict2)
1778         # Make all P fields that haven't already been constructed
1779 
1780 
1781     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1782         'Writes this packet to the supplied buffer'
1783         self._bufferstartoffset=buf.getcurrentoffset()
1784         self.__field_byte.writetobuffer(buf)
1785         self._bufferendoffset=buf.getcurrentoffset()
1786         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1787 
1788 
1789     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1790         'Reads this packet from the supplied buffer'
1791         self._bufferstartoffset=buf.getcurrentoffset()
1792         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1793         self.__field_byte=UINT(**{'sizeinbytes': 1})
1794         self.__field_byte.readfrombuffer(buf)
1795         self._bufferendoffset=buf.getcurrentoffset()
1796 
1797 
1798     def __getfield_byte(self):
1799         return self.__field_byte.getvalue()
1800 
1801     def __setfield_byte(self, value):
1802         if isinstance(value,UINT):
1803             self.__field_byte=value
1804         else:
1805             self.__field_byte=UINT(value,**{'sizeinbytes': 1})
1806 
1807     def __delfield_byte(self): del self.__field_byte
1808 
1809     byte=property(__getfield_byte, __setfield_byte, __delfield_byte, "individual byte of message")
1810 
1811     def iscontainer(self):
1812         return True
1813 
1814     def containerelements(self):
1815         yield ('byte', self.__field_byte, "individual byte of message")
1816 
1817 
1818 
1819 
1820 class recipient_record(BaseProtogenClass):
1821     __fields=['unknown1', 'number', 'status', 'timesent', 'timereceived', 'unknown2']
1822 
1823     def __init__(self, *args, **kwargs):
1824         dict={}
1825         # What was supplied to this function
1826         dict.update(kwargs)
1827         # Parent constructor
1828         super(recipient_record,self).__init__(**dict)
1829         if self.__class__ is recipient_record:
1830             self._update(args,dict)
1831 
1832 
1833     def getfields(self):
1834         return self.__fields
1835 
1836 
1837     def _update(self, args, kwargs):
1838         super(recipient_record,self)._update(args,kwargs)
1839         keys=kwargs.keys()
1840         for key in keys:
1841             if key in self.__fields:
1842                 setattr(self, key, kwargs[key])
1843                 del kwargs[key]
1844         # Were any unrecognized kwargs passed in?
1845         if __debug__:
1846             self._complainaboutunusedargs(recipient_record,kwargs)
1847         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1848         # Make all P fields that haven't already been constructed
1849 
1850 
1851     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1852         'Writes this packet to the supplied buffer'
1853         self._bufferstartoffset=buf.getcurrentoffset()
1854         self.__field_unknown1.writetobuffer(buf)
1855         self.__field_number.writetobuffer(buf)
1856         self.__field_status.writetobuffer(buf)
1857         self.__field_timesent.writetobuffer(buf)
1858         self.__field_timereceived.writetobuffer(buf)
1859         self.__field_unknown2.writetobuffer(buf)
1860         self._bufferendoffset=buf.getcurrentoffset()
1861         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1862 
1863 
1864     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1865         'Reads this packet from the supplied buffer'
1866         self._bufferstartoffset=buf.getcurrentoffset()
1867         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1868         self.__field_unknown1=UINT(**{'sizeinbytes': 2})
1869         self.__field_unknown1.readfrombuffer(buf)
1870         self.__field_number=USTRING(**{'sizeinbytes': 49})
1871         self.__field_number.readfrombuffer(buf)
1872         self.__field_status=UINT(**{'sizeinbytes': 1})
1873         self.__field_status.readfrombuffer(buf)
1874         self.__field_timesent=LGCALDATE(**{'sizeinbytes': 4})
1875         self.__field_timesent.readfrombuffer(buf)
1876         self.__field_timereceived=LGCALDATE(**{'sizeinbytes': 4})
1877         self.__field_timereceived.readfrombuffer(buf)
1878         self.__field_unknown2=DATA(**{'sizeinbytes': 8})
1879         self.__field_unknown2.readfrombuffer(buf)
1880         self._bufferendoffset=buf.getcurrentoffset()
1881 
1882 
1883     def __getfield_unknown1(self):
1884         return self.__field_unknown1.getvalue()
1885 
1886     def __setfield_unknown1(self, value):
1887         if isinstance(value,UINT):
1888             self.__field_unknown1=value
1889         else:
1890             self.__field_unknown1=UINT(value,**{'sizeinbytes': 2})
1891 
1892     def __delfield_unknown1(self): del self.__field_unknown1
1893 
1894     unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None)
1895 
1896     def __getfield_number(self):
1897         return self.__field_number.getvalue()
1898 
1899     def __setfield_number(self, value):
1900         if isinstance(value,USTRING):
1901             self.__field_number=value
1902         else:
1903             self.__field_number=USTRING(value,**{'sizeinbytes': 49})
1904 
1905     def __delfield_number(self): del self.__field_number
1906 
1907     number=property(__getfield_number, __setfield_number, __delfield_number, None)
1908 
1909     def __getfield_status(self):
1910         return self.__field_status.getvalue()
1911 
1912     def __setfield_status(self, value):
1913         if isinstance(value,UINT):
1914             self.__field_status=value
1915         else:
1916             self.__field_status=UINT(value,**{'sizeinbytes': 1})
1917 
1918     def __delfield_status(self): del self.__field_status
1919 
1920     status=property(__getfield_status, __setfield_status, __delfield_status, None)
1921 
1922     def __getfield_timesent(self):
1923         return self.__field_timesent.getvalue()
1924 
1925     def __setfield_timesent(self, value):
1926         if isinstance(value,LGCALDATE):
1927             self.__field_timesent=value
1928         else:
1929             self.__field_timesent=LGCALDATE(value,**{'sizeinbytes': 4})
1930 
1931     def __delfield_timesent(self): del self.__field_timesent
1932 
1933     timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None)
1934 
1935     def __getfield_timereceived(self):
1936         return self.__field_timereceived.getvalue()
1937 
1938     def __setfield_timereceived(self, value):
1939         if isinstance(value,LGCALDATE):
1940             self.__field_timereceived=value
1941         else:
1942             self.__field_timereceived=LGCALDATE(value,**{'sizeinbytes': 4})
1943 
1944     def __delfield_timereceived(self): del self.__field_timereceived
1945 
1946     timereceived=property(__getfield_timereceived, __setfield_timereceived, __delfield_timereceived, None)
1947 
1948     def __getfield_unknown2(self):
1949         return self.__field_unknown2.getvalue()
1950 
1951     def __setfield_unknown2(self, value):
1952         if isinstance(value,DATA):
1953             self.__field_unknown2=value
1954         else:
1955             self.__field_unknown2=DATA(value,**{'sizeinbytes': 8})
1956 
1957     def __delfield_unknown2(self): del self.__field_unknown2
1958 
1959     unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None)
1960 
1961     def iscontainer(self):
1962         return True
1963 
1964     def containerelements(self):
1965         yield ('unknown1', self.__field_unknown1, None)
1966         yield ('number', self.__field_number, None)
1967         yield ('status', self.__field_status, None)
1968         yield ('timesent', self.__field_timesent, None)
1969         yield ('timereceived', self.__field_timereceived, None)
1970         yield ('unknown2', self.__field_unknown2, None)
1971 
1972 
1973 
1974 
1975 class sms_saved(BaseProtogenClass):
1976     __fields=['outboxmsg', 'pad', 'outbox', 'inbox']
1977 
1978     def __init__(self, *args, **kwargs):
1979         dict={}
1980         # What was supplied to this function
1981         dict.update(kwargs)
1982         # Parent constructor
1983         super(sms_saved,self).__init__(**dict)
1984         if self.__class__ is sms_saved:
1985             self._update(args,dict)
1986 
1987 
1988     def getfields(self):
1989         return self.__fields
1990 
1991 
1992     def _update(self, args, kwargs):
1993         super(sms_saved,self)._update(args,kwargs)
1994         keys=kwargs.keys()
1995         for key in keys:
1996             if key in self.__fields:
1997                 setattr(self, key, kwargs[key])
1998                 del kwargs[key]
1999         # Were any unrecognized kwargs passed in?
2000         if __debug__:
2001             self._complainaboutunusedargs(sms_saved,kwargs)
2002         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2003         # Make all P fields that haven't already been constructed
2004 
2005 
2006     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2007         'Writes this packet to the supplied buffer'
2008         self._bufferstartoffset=buf.getcurrentoffset()
2009         self.__field_outboxmsg.writetobuffer(buf)
2010         self.__field_pad.writetobuffer(buf)
2011         if self.outboxmsg:
2012             self.__field_outbox.writetobuffer(buf)
2013         if not self.outboxmsg:
2014             self.__field_inbox.writetobuffer(buf)
2015         self._bufferendoffset=buf.getcurrentoffset()
2016         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2017 
2018 
2019     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2020         'Reads this packet from the supplied buffer'
2021         self._bufferstartoffset=buf.getcurrentoffset()
2022         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2023         self.__field_outboxmsg=UINT(**{'sizeinbytes': 4})
2024         self.__field_outboxmsg.readfrombuffer(buf)
2025         self.__field_pad=UNKNOWN(**{'sizeinbytes': 4})
2026         self.__field_pad.readfrombuffer(buf)
2027         if self.outboxmsg:
2028             self.__field_outbox=sms_out()
2029             self.__field_outbox.readfrombuffer(buf)
2030         if not self.outboxmsg:
2031             self.__field_inbox=sms_in()
2032             self.__field_inbox.readfrombuffer(buf)
2033         self._bufferendoffset=buf.getcurrentoffset()
2034 
2035 
2036     def __getfield_outboxmsg(self):
2037         return self.__field_outboxmsg.getvalue()
2038 
2039     def __setfield_outboxmsg(self, value):
2040         if isinstance(value,UINT):
2041             self.__field_outboxmsg=value
2042         else:
2043             self.__field_outboxmsg=UINT(value,**{'sizeinbytes': 4})
2044 
2045     def __delfield_outboxmsg(self): del self.__field_outboxmsg
2046 
2047     outboxmsg=property(__getfield_outboxmsg, __setfield_outboxmsg, __delfield_outboxmsg, None)
2048 
2049     def __getfield_pad(self):
2050         return self.__field_pad.getvalue()
2051 
2052     def __setfield_pad(self, value):
2053         if isinstance(value,UNKNOWN):
2054             self.__field_pad=value
2055         else:
2056             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 4})
2057 
2058     def __delfield_pad(self): del self.__field_pad
2059 
2060     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
2061 
2062     def __getfield_outbox(self):
2063         return self.__field_outbox.getvalue()
2064 
2065     def __setfield_outbox(self, value):
2066         if isinstance(value,sms_out):
2067             self.__field_outbox=value
2068         else:
2069             self.__field_outbox=sms_out(value,)
2070 
2071     def __delfield_outbox(self): del self.__field_outbox
2072 
2073     outbox=property(__getfield_outbox, __setfield_outbox, __delfield_outbox, None)
2074 
2075     def __getfield_inbox(self):
2076         return self.__field_inbox.getvalue()
2077 
2078     def __setfield_inbox(self, value):
2079         if isinstance(value,sms_in):
2080             self.__field_inbox=value
2081         else:
2082             self.__field_inbox=sms_in(value,)
2083 
2084     def __delfield_inbox(self): del self.__field_inbox
2085 
2086     inbox=property(__getfield_inbox, __setfield_inbox, __delfield_inbox, None)
2087 
2088     def iscontainer(self):
2089         return True
2090 
2091     def containerelements(self):
2092         yield ('outboxmsg', self.__field_outboxmsg, None)
2093         yield ('pad', self.__field_pad, None)
2094         if self.outboxmsg:
2095             yield ('outbox', self.__field_outbox, None)
2096         if not self.outboxmsg:
2097             yield ('inbox', self.__field_inbox, None)
2098 
2099 
2100 
2101 
2102 class sms_out(BaseProtogenClass):
2103     __fields=['callback', 'index', 'locked', 'unknown1', 'timesent', 'subject', 'unknown2', 'num_msg_elements', 'messages', 'unknown5', 'priority', 'unknown7', 'callback', 'recipients']
2104 
2105     def __init__(self, *args, **kwargs):
2106         dict={}
2107         # What was supplied to this function
2108         dict.update(kwargs)
2109         # Parent constructor
2110         super(sms_out,self).__init__(**dict)
2111         if self.__class__ is sms_out:
2112             self._update(args,dict)
2113 
2114 
2115     def getfields(self):
2116         return self.__fields
2117 
2118 
2119     def _update(self, args, kwargs):
2120         super(sms_out,self)._update(args,kwargs)
2121         keys=kwargs.keys()
2122         for key in keys:
2123             if key in self.__fields:
2124                 setattr(self, key, kwargs[key])
2125                 del kwargs[key]
2126         # Were any unrecognized kwargs passed in?
2127         if __debug__:
2128             self._complainaboutunusedargs(sms_out,kwargs)
2129         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2130         # Make all P fields that haven't already been constructed
2131         try: self.__field_callback
2132         except:
2133             self.__field_callback=USTRING(**{ 'default': '' })
2134 
2135 
2136     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2137         'Writes this packet to the supplied buffer'
2138         self._bufferstartoffset=buf.getcurrentoffset()
2139         self.__field_index.writetobuffer(buf)
2140         self.__field_locked.writetobuffer(buf)
2141         self.__field_unknown1.writetobuffer(buf)
2142         self.__field_timesent.writetobuffer(buf)
2143         self.__field_subject.writetobuffer(buf)
2144         self.__field_unknown2.writetobuffer(buf)
2145         self.__field_num_msg_elements.writetobuffer(buf)
2146         try: self.__field_messages
2147         except:
2148             self.__field_messages=LIST(**{'elementclass': msg_record, 'length': 10})
2149         self.__field_messages.writetobuffer(buf)
2150         self.__field_unknown5.writetobuffer(buf)
2151         self.__field_priority.writetobuffer(buf)
2152         self.__field_unknown7.writetobuffer(buf)
2153         self.__field_callback.writetobuffer(buf)
2154         try: self.__field_recipients
2155         except:
2156             self.__field_recipients=LIST(**{'elementclass': recipient_record,'length': 10})
2157         self.__field_recipients.writetobuffer(buf)
2158         self._bufferendoffset=buf.getcurrentoffset()
2159         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2160 
2161 
2162     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2163         'Reads this packet from the supplied buffer'
2164         self._bufferstartoffset=buf.getcurrentoffset()
2165         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2166         self.__field_index=UINT(**{'sizeinbytes': 4})
2167         self.__field_index.readfrombuffer(buf)
2168         self.__field_locked=UINT(**{'sizeinbytes': 1})
2169         self.__field_locked.readfrombuffer(buf)
2170         self.__field_unknown1=UINT(**{'sizeinbytes': 3})
2171         self.__field_unknown1.readfrombuffer(buf)
2172         self.__field_timesent=LGCALDATE(**{'sizeinbytes': 4})
2173         self.__field_timesent.readfrombuffer(buf)
2174         self.__field_subject=USTRING(**{'sizeinbytes': 21, 'encoding': PHONE_ENCODING})
2175         self.__field_subject.readfrombuffer(buf)
2176         self.__field_unknown2=DATA(**{'sizeinbytes': 151})
2177         self.__field_unknown2.readfrombuffer(buf)
2178         self.__field_num_msg_elements=UINT(**{'sizeinbytes': 1})
2179         self.__field_num_msg_elements.readfrombuffer(buf)
2180         self.__field_messages=LIST(**{'elementclass': msg_record, 'length': 10})
2181         self.__field_messages.readfrombuffer(buf)
2182         self.__field_unknown5=UINT(**{'sizeinbytes': 1})
2183         self.__field_unknown5.readfrombuffer(buf)
2184         self.__field_priority=UINT(**{'sizeinbytes': 1})
2185         self.__field_priority.readfrombuffer(buf)
2186         self.__field_unknown7=DATA(**{'sizeinbytes': 15})
2187         self.__field_unknown7.readfrombuffer(buf)
2188         self.__field_callback=USTRING(**{'sizeinbytes': 24})
2189         self.__field_callback.readfrombuffer(buf)
2190         self.__field_recipients=LIST(**{'elementclass': recipient_record,'length': 10})
2191         self.__field_recipients.readfrombuffer(buf)
2192         self._bufferendoffset=buf.getcurrentoffset()
2193 
2194 
2195     def __getfield_callback(self):
2196         return self.__field_callback.getvalue()
2197 
2198     def __setfield_callback(self, value):
2199         if isinstance(value,USTRING):
2200             self.__field_callback=value
2201         else:
2202             self.__field_callback=USTRING(value,**{ 'default': '' })
2203 
2204     def __delfield_callback(self): del self.__field_callback
2205 
2206     callback=property(__getfield_callback, __setfield_callback, __delfield_callback, None)
2207 
2208     def __getfield_index(self):
2209         return self.__field_index.getvalue()
2210 
2211     def __setfield_index(self, value):
2212         if isinstance(value,UINT):
2213             self.__field_index=value
2214         else:
2215             self.__field_index=UINT(value,**{'sizeinbytes': 4})
2216 
2217     def __delfield_index(self): del self.__field_index
2218 
2219     index=property(__getfield_index, __setfield_index, __delfield_index, None)
2220 
2221     def __getfield_locked(self):
2222         return self.__field_locked.getvalue()
2223 
2224     def __setfield_locked(self, value):
2225         if isinstance(value,UINT):
2226             self.__field_locked=value
2227         else:
2228             self.__field_locked=UINT(value,**{'sizeinbytes': 1})
2229 
2230     def __delfield_locked(self): del self.__field_locked
2231 
2232     locked=property(__getfield_locked, __setfield_locked, __delfield_locked, None)
2233 
2234     def __getfield_unknown1(self):
2235         return self.__field_unknown1.getvalue()
2236 
2237     def __setfield_unknown1(self, value):
2238         if isinstance(value,UINT):
2239             self.__field_unknown1=value
2240         else:
2241             self.__field_unknown1=UINT(value,**{'sizeinbytes': 3})
2242 
2243     def __delfield_unknown1(self): del self.__field_unknown1
2244 
2245     unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None)
2246 
2247     def __getfield_timesent(self):
2248         return self.__field_timesent.getvalue()
2249 
2250     def __setfield_timesent(self, value):
2251         if isinstance(value,LGCALDATE):
2252             self.__field_timesent=value
2253         else:
2254             self.__field_timesent=LGCALDATE(value,**{'sizeinbytes': 4})
2255 
2256     def __delfield_timesent(self): del self.__field_timesent
2257 
2258     timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None)
2259 
2260     def __getfield_subject(self):
2261         return self.__field_subject.getvalue()
2262 
2263     def __setfield_subject(self, value):
2264         if isinstance(value,USTRING):
2265             self.__field_subject=value
2266         else:
2267             self.__field_subject=USTRING(value,**{'sizeinbytes': 21, 'encoding': PHONE_ENCODING})
2268 
2269     def __delfield_subject(self): del self.__field_subject
2270 
2271     subject=property(__getfield_subject, __setfield_subject, __delfield_subject, None)
2272 
2273     def __getfield_unknown2(self):
2274         return self.__field_unknown2.getvalue()
2275 
2276     def __setfield_unknown2(self, value):
2277         if isinstance(value,DATA):
2278             self.__field_unknown2=value
2279         else:
2280             self.__field_unknown2=DATA(value,**{'sizeinbytes': 151})
2281 
2282     def __delfield_unknown2(self): del self.__field_unknown2
2283 
2284     unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None)
2285 
2286     def __getfield_num_msg_elements(self):
2287         return self.__field_num_msg_elements.getvalue()
2288 
2289     def __setfield_num_msg_elements(self, value):
2290         if isinstance(value,UINT):
2291             self.__field_num_msg_elements=value
2292         else:
2293             self.__field_num_msg_elements=UINT(value,**{'sizeinbytes': 1})
2294 
2295     def __delfield_num_msg_elements(self): del self.__field_num_msg_elements
2296 
2297     num_msg_elements=property(__getfield_num_msg_elements, __setfield_num_msg_elements, __delfield_num_msg_elements, None)
2298 
2299     def __getfield_messages(self):
2300         try: self.__field_messages
2301         except:
2302             self.__field_messages=LIST(**{'elementclass': msg_record, 'length': 10})
2303         return self.__field_messages.getvalue()
2304 
2305     def __setfield_messages(self, value):
2306         if isinstance(value,LIST):
2307             self.__field_messages=value
2308         else:
2309             self.__field_messages=LIST(value,**{'elementclass': msg_record, 'length': 10})
2310 
2311     def __delfield_messages(self): del self.__field_messages
2312 
2313     messages=property(__getfield_messages, __setfield_messages, __delfield_messages, None)
2314 
2315     def __getfield_unknown5(self):
2316         return self.__field_unknown5.getvalue()
2317 
2318     def __setfield_unknown5(self, value):
2319         if isinstance(value,UINT):
2320             self.__field_unknown5=value
2321         else:
2322             self.__field_unknown5=UINT(value,**{'sizeinbytes': 1})
2323 
2324     def __delfield_unknown5(self): del self.__field_unknown5
2325 
2326     unknown5=property(__getfield_unknown5, __setfield_unknown5, __delfield_unknown5, None)
2327 
2328     def __getfield_priority(self):
2329         return self.__field_priority.getvalue()
2330 
2331     def __setfield_priority(self, value):
2332         if isinstance(value,UINT):
2333             self.__field_priority=value
2334         else:
2335             self.__field_priority=UINT(value,**{'sizeinbytes': 1})
2336 
2337     def __delfield_priority(self): del self.__field_priority
2338 
2339     priority=property(__getfield_priority, __setfield_priority, __delfield_priority, None)
2340 
2341     def __getfield_unknown7(self):
2342         return self.__field_unknown7.getvalue()
2343 
2344     def __setfield_unknown7(self, value):
2345         if isinstance(value,DATA):
2346             self.__field_unknown7=value
2347         else:
2348             self.__field_unknown7=DATA(value,**{'sizeinbytes': 15})
2349 
2350     def __delfield_unknown7(self): del self.__field_unknown7
2351 
2352     unknown7=property(__getfield_unknown7, __setfield_unknown7, __delfield_unknown7, None)
2353 
2354     def __getfield_callback(self):
2355         return self.__field_callback.getvalue()
2356 
2357     def __setfield_callback(self, value):
2358         if isinstance(value,USTRING):
2359             self.__field_callback=value
2360         else:
2361             self.__field_callback=USTRING(value,**{'sizeinbytes': 24})
2362 
2363     def __delfield_callback(self): del self.__field_callback
2364 
2365     callback=property(__getfield_callback, __setfield_callback, __delfield_callback, None)
2366 
2367     def __getfield_recipients(self):
2368         try: self.__field_recipients
2369         except:
2370             self.__field_recipients=LIST(**{'elementclass': recipient_record,'length': 10})
2371         return self.__field_recipients.getvalue()
2372 
2373     def __setfield_recipients(self, value):
2374         if isinstance(value,LIST):
2375             self.__field_recipients=value
2376         else:
2377             self.__field_recipients=LIST(value,**{'elementclass': recipient_record,'length': 10})
2378 
2379     def __delfield_recipients(self): del self.__field_recipients
2380 
2381     recipients=property(__getfield_recipients, __setfield_recipients, __delfield_recipients, None)
2382 
2383     def iscontainer(self):
2384         return True
2385 
2386     def containerelements(self):
2387         yield ('callback', self.__field_callback, None)
2388         yield ('index', self.__field_index, None)
2389         yield ('locked', self.__field_locked, None)
2390         yield ('unknown1', self.__field_unknown1, None)
2391         yield ('timesent', self.__field_timesent, None)
2392         yield ('subject', self.__field_subject, None)
2393         yield ('unknown2', self.__field_unknown2, None)
2394         yield ('num_msg_elements', self.__field_num_msg_elements, None)
2395         yield ('messages', self.__field_messages, None)
2396         yield ('unknown5', self.__field_unknown5, None)
2397         yield ('priority', self.__field_priority, None)
2398         yield ('unknown7', self.__field_unknown7, None)
2399         yield ('callback', self.__field_callback, None)
2400         yield ('recipients', self.__field_recipients, None)
2401 
2402 
2403 
2404 
2405 class SMSINBOXMSGFRAGMENT(BaseProtogenClass):
2406     __fields=['msg']
2407 
2408     def __init__(self, *args, **kwargs):
2409         dict={}
2410         # What was supplied to this function
2411         dict.update(kwargs)
2412         # Parent constructor
2413         super(SMSINBOXMSGFRAGMENT,self).__init__(**dict)
2414         if self.__class__ is SMSINBOXMSGFRAGMENT:
2415             self._update(args,dict)
2416 
2417 
2418     def getfields(self):
2419         return self.__fields
2420 
2421 
2422     def _update(self, args, kwargs):
2423         super(SMSINBOXMSGFRAGMENT,self)._update(args,kwargs)
2424         keys=kwargs.keys()
2425         for key in keys:
2426             if key in self.__fields:
2427                 setattr(self, key, kwargs[key])
2428                 del kwargs[key]
2429         # Were any unrecognized kwargs passed in?
2430         if __debug__:
2431             self._complainaboutunusedargs(SMSINBOXMSGFRAGMENT,kwargs)
2432         if len(args):
2433             dict2={'elementclass': _gen_p_lglx5450_222, 'length': 181}
2434             dict2.update(kwargs)
2435             kwargs=dict2
2436             self.__field_msg=LIST(*args,**dict2)
2437         # Make all P fields that haven't already been constructed
2438 
2439 
2440     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2441         'Writes this packet to the supplied buffer'
2442         self._bufferstartoffset=buf.getcurrentoffset()
2443         try: self.__field_msg
2444         except:
2445             self.__field_msg=LIST(**{'elementclass': _gen_p_lglx5450_222, 'length': 181})
2446         self.__field_msg.writetobuffer(buf)
2447         self._bufferendoffset=buf.getcurrentoffset()
2448         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2449 
2450 
2451     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2452         'Reads this packet from the supplied buffer'
2453         self._bufferstartoffset=buf.getcurrentoffset()
2454         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2455         self.__field_msg=LIST(**{'elementclass': _gen_p_lglx5450_222, 'length': 181})
2456         self.__field_msg.readfrombuffer(buf)
2457         self._bufferendoffset=buf.getcurrentoffset()
2458 
2459 
2460     def __getfield_msg(self):
2461         try: self.__field_msg
2462         except:
2463             self.__field_msg=LIST(**{'elementclass': _gen_p_lglx5450_222, 'length': 181})
2464         return self.__field_msg.getvalue()
2465 
2466     def __setfield_msg(self, value):
2467         if isinstance(value,LIST):
2468             self.__field_msg=value
2469         else:
2470             self.__field_msg=LIST(value,**{'elementclass': _gen_p_lglx5450_222, 'length': 181})
2471 
2472     def __delfield_msg(self): del self.__field_msg
2473 
2474     msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None)
2475 
2476     def iscontainer(self):
2477         return True
2478 
2479     def containerelements(self):
2480         yield ('msg', self.__field_msg, None)
2481 
2482 
2483 
2484 
2485 class _gen_p_lglx5450_222(BaseProtogenClass):
2486     'Anonymous inner class'
2487     __fields=['byte']
2488 
2489     def __init__(self, *args, **kwargs):
2490         dict={}
2491         # What was supplied to this function
2492         dict.update(kwargs)
2493         # Parent constructor
2494         super(_gen_p_lglx5450_222,self).__init__(**dict)
2495         if self.__class__ is _gen_p_lglx5450_222:
2496             self._update(args,dict)
2497 
2498 
2499     def getfields(self):
2500         return self.__fields
2501 
2502 
2503     def _update(self, args, kwargs):
2504         super(_gen_p_lglx5450_222,self)._update(args,kwargs)
2505         keys=kwargs.keys()
2506         for key in keys:
2507             if key in self.__fields:
2508                 setattr(self, key, kwargs[key])
2509                 del kwargs[key]
2510         # Were any unrecognized kwargs passed in?
2511         if __debug__:
2512             self._complainaboutunusedargs(_gen_p_lglx5450_222,kwargs)
2513         if len(args):
2514             dict2={'sizeinbytes': 1}
2515             dict2.update(kwargs)
2516             kwargs=dict2
2517             self.__field_byte=UINT(*args,**dict2)
2518         # Make all P fields that haven't already been constructed
2519 
2520 
2521     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2522         'Writes this packet to the supplied buffer'
2523         self._bufferstartoffset=buf.getcurrentoffset()
2524         self.__field_byte.writetobuffer(buf)
2525         self._bufferendoffset=buf.getcurrentoffset()
2526         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2527 
2528 
2529     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2530         'Reads this packet from the supplied buffer'
2531         self._bufferstartoffset=buf.getcurrentoffset()
2532         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2533         self.__field_byte=UINT(**{'sizeinbytes': 1})
2534         self.__field_byte.readfrombuffer(buf)
2535         self._bufferendoffset=buf.getcurrentoffset()
2536 
2537 
2538     def __getfield_byte(self):
2539         return self.__field_byte.getvalue()
2540 
2541     def __setfield_byte(self, value):
2542         if isinstance(value,UINT):
2543             self.__field_byte=value
2544         else:
2545             self.__field_byte=UINT(value,**{'sizeinbytes': 1})
2546 
2547     def __delfield_byte(self): del self.__field_byte
2548 
2549     byte=property(__getfield_byte, __setfield_byte, __delfield_byte, "individual byte of message")
2550 
2551     def iscontainer(self):
2552         return True
2553 
2554     def containerelements(self):
2555         yield ('byte', self.__field_byte, "individual byte of message")
2556 
2557 
2558 
2559 
2560 class sms_in(BaseProtogenClass):
2561     __fields=['msg_index1', 'msg_index2', 'unknown2', 'unknown3', 'timesent', 'unknown', 'callback_length', 'callback', 'sender_length', 'sender', 'unknown4', 'lg_time', 'GPStime', 'unknown5', 'read', 'locked', 'unknown8', 'priority', 'flags', 'subject', 'bin_header1', 'bin_header2', 'unknown6', 'multipartID', 'bin_header3', 'num_msg_elements', 'msglengths', 'msgs', 'unknown5', 'senders_name', 'unknown6']
2562 
2563     def __init__(self, *args, **kwargs):
2564         dict={}
2565         # What was supplied to this function
2566         dict.update(kwargs)
2567         # Parent constructor
2568         super(sms_in,self).__init__(**dict)
2569         if self.__class__ is sms_in:
2570             self._update(args,dict)
2571 
2572 
2573     def getfields(self):
2574         return self.__fields
2575 
2576 
2577     def _update(self, args, kwargs):
2578         super(sms_in,self)._update(args,kwargs)
2579         keys=kwargs.keys()
2580         for key in keys:
2581             if key in self.__fields:
2582                 setattr(self, key, kwargs[key])
2583                 del kwargs[key]
2584         # Were any unrecognized kwargs passed in?
2585         if __debug__:
2586             self._complainaboutunusedargs(sms_in,kwargs)
2587         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2588         # Make all P fields that haven't already been constructed
2589 
2590 
2591     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2592         'Writes this packet to the supplied buffer'
2593         self._bufferstartoffset=buf.getcurrentoffset()
2594         self.__field_msg_index1.writetobuffer(buf)
2595         self.__field_msg_index2.writetobuffer(buf)
2596         self.__field_unknown2.writetobuffer(buf)
2597         self.__field_unknown3.writetobuffer(buf)
2598         self.__field_timesent.writetobuffer(buf)
2599         self.__field_unknown.writetobuffer(buf)
2600         self.__field_callback_length.writetobuffer(buf)
2601         self.__field_callback.writetobuffer(buf)
2602         self.__field_sender_length.writetobuffer(buf)
2603         try: self.__field_sender
2604         except:
2605             self.__field_sender=LIST(**{'elementclass': _gen_p_lglx5450_235, 'length': 38})
2606         self.__field_sender.writetobuffer(buf)
2607         self.__field_unknown4.writetobuffer(buf)
2608         self.__field_lg_time.writetobuffer(buf)
2609         self.__field_GPStime.writetobuffer(buf)
2610         self.__field_unknown5.writetobuffer(buf)
2611         self.__field_read.writetobuffer(buf)
2612         self.__field_locked.writetobuffer(buf)
2613         self.__field_unknown8.writetobuffer(buf)
2614         self.__field_priority.writetobuffer(buf)
2615         self.__field_flags.writetobuffer(buf)
2616         self.__field_subject.writetobuffer(buf)
2617         self.__field_bin_header1.writetobuffer(buf)
2618         self.__field_bin_header2.writetobuffer(buf)
2619         self.__field_unknown6.writetobuffer(buf)
2620         self.__field_multipartID.writetobuffer(buf)
2621         self.__field_bin_header3.writetobuffer(buf)
2622         self.__field_num_msg_elements.writetobuffer(buf)
2623         try: self.__field_msglengths
2624         except:
2625             self.__field_msglengths=LIST(**{'elementclass': _gen_p_lglx5450_253, 'length': 10})
2626         self.__field_msglengths.writetobuffer(buf)
2627         try: self.__field_msgs
2628         except:
2629             self.__field_msgs=LIST(**{'length': 10, 'elementclass': SMSINBOXMSGFRAGMENT})
2630         self.__field_msgs.writetobuffer(buf)
2631         self.__field_unknown5.writetobuffer(buf)
2632         self.__field_senders_name.writetobuffer(buf)
2633         self.__field_unknown6.writetobuffer(buf)
2634         self._bufferendoffset=buf.getcurrentoffset()
2635         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2636 
2637 
2638     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2639         'Reads this packet from the supplied buffer'
2640         self._bufferstartoffset=buf.getcurrentoffset()
2641         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2642         self.__field_msg_index1=UINT(**{'sizeinbytes': 4})
2643         self.__field_msg_index1.readfrombuffer(buf)
2644         self.__field_msg_index2=UINT(**{'sizeinbytes': 4})
2645         self.__field_msg_index2.readfrombuffer(buf)
2646         self.__field_unknown2=UINT(**{'sizeinbytes': 2})
2647         self.__field_unknown2.readfrombuffer(buf)
2648         self.__field_unknown3=UINT(**{'sizeinbytes': 4})
2649         self.__field_unknown3.readfrombuffer(buf)
2650         self.__field_timesent=SMSDATE(**{'sizeinbytes': 6})
2651         self.__field_timesent.readfrombuffer(buf)
2652         self.__field_unknown=UINT(**{'sizeinbytes': 3})
2653         self.__field_unknown.readfrombuffer(buf)
2654         self.__field_callback_length=UINT(**{'sizeinbytes': 1})
2655         self.__field_callback_length.readfrombuffer(buf)
2656         self.__field_callback=USTRING(**{'sizeinbytes': 38})
2657         self.__field_callback.readfrombuffer(buf)
2658         self.__field_sender_length=UINT(**{'sizeinbytes': 1})
2659         self.__field_sender_length.readfrombuffer(buf)
2660         self.__field_sender=LIST(**{'elementclass': _gen_p_lglx5450_235, 'length': 38})
2661         self.__field_sender.readfrombuffer(buf)
2662         self.__field_unknown4=DATA(**{'sizeinbytes': 15})
2663         self.__field_unknown4.readfrombuffer(buf)
2664         self.__field_lg_time=LGCALDATE(**{'sizeinbytes': 4})
2665         self.__field_lg_time.readfrombuffer(buf)
2666         self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4})
2667         self.__field_GPStime.readfrombuffer(buf)
2668         self.__field_unknown5=UINT(**{'sizeinbytes': 2})
2669         self.__field_unknown5.readfrombuffer(buf)
2670         self.__field_read=UINT(**{'sizeinbytes': 1})
2671         self.__field_read.readfrombuffer(buf)
2672         self.__field_locked=UINT(**{'sizeinbytes': 1})
2673         self.__field_locked.readfrombuffer(buf)
2674         self.__field_unknown8=UINT(**{'sizeinbytes': 2})
2675         self.__field_unknown8.readfrombuffer(buf)
2676         self.__field_priority=UINT(**{'sizeinbytes': 1})
2677         self.__field_priority.readfrombuffer(buf)
2678         self.__field_flags=DATA(**{'sizeinbytes': 5})
2679         self.__field_flags.readfrombuffer(buf)
2680         self.__field_subject=USTRING(**{'sizeinbytes': 21, 'encoding': PHONE_ENCODING})
2681         self.__field_subject.readfrombuffer(buf)
2682         self.__field_bin_header1=UINT(**{'sizeinbytes': 1})
2683         self.__field_bin_header1.readfrombuffer(buf)
2684         self.__field_bin_header2=UINT(**{'sizeinbytes': 1})
2685         self.__field_bin_header2.readfrombuffer(buf)
2686         self.__field_unknown6=UINT(**{'sizeinbytes': 2})
2687         self.__field_unknown6.readfrombuffer(buf)
2688         self.__field_multipartID=UINT(**{'sizeinbytes': 2})
2689         self.__field_multipartID.readfrombuffer(buf)
2690         self.__field_bin_header3=UINT(**{'sizeinbytes': 1})
2691         self.__field_bin_header3.readfrombuffer(buf)
2692         self.__field_num_msg_elements=UINT(**{'sizeinbytes': 1})
2693         self.__field_num_msg_elements.readfrombuffer(buf)
2694         self.__field_msglengths=LIST(**{'elementclass': _gen_p_lglx5450_253, 'length': 10})
2695         self.__field_msglengths.readfrombuffer(buf)
2696         self.__field_msgs=LIST(**{'length': 10, 'elementclass': SMSINBOXMSGFRAGMENT})
2697         self.__field_msgs.readfrombuffer(buf)
2698         self.__field_unknown5=DATA(**{'sizeinbytes': 437})
2699         self.__field_unknown5.readfrombuffer(buf)
2700         self.__field_senders_name=USTRING(**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING})
2701         self.__field_senders_name.readfrombuffer(buf)
2702         self.__field_unknown6=DATA(**{'sizeinbytes': 169})
2703         self.__field_unknown6.readfrombuffer(buf)
2704         self._bufferendoffset=buf.getcurrentoffset()
2705 
2706 
2707     def __getfield_msg_index1(self):
2708         return self.__field_msg_index1.getvalue()
2709 
2710     def __setfield_msg_index1(self, value):
2711         if isinstance(value,UINT):
2712             self.__field_msg_index1=value
2713         else:
2714             self.__field_msg_index1=UINT(value,**{'sizeinbytes': 4})
2715 
2716     def __delfield_msg_index1(self): del self.__field_msg_index1
2717 
2718     msg_index1=property(__getfield_msg_index1, __setfield_msg_index1, __delfield_msg_index1, None)
2719 
2720     def __getfield_msg_index2(self):
2721         return self.__field_msg_index2.getvalue()
2722 
2723     def __setfield_msg_index2(self, value):
2724         if isinstance(value,UINT):
2725             self.__field_msg_index2=value
2726         else:
2727             self.__field_msg_index2=UINT(value,**{'sizeinbytes': 4})
2728 
2729     def __delfield_msg_index2(self): del self.__field_msg_index2
2730 
2731     msg_index2=property(__getfield_msg_index2, __setfield_msg_index2, __delfield_msg_index2, None)
2732 
2733     def __getfield_unknown2(self):
2734         return self.__field_unknown2.getvalue()
2735 
2736     def __setfield_unknown2(self, value):
2737         if isinstance(value,UINT):
2738             self.__field_unknown2=value
2739         else:
2740             self.__field_unknown2=UINT(value,**{'sizeinbytes': 2})
2741 
2742     def __delfield_unknown2(self): del self.__field_unknown2
2743 
2744     unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None)
2745 
2746     def __getfield_unknown3(self):
2747         return self.__field_unknown3.getvalue()
2748 
2749     def __setfield_unknown3(self, value):
2750         if isinstance(value,UINT):
2751             self.__field_unknown3=value
2752         else:
2753             self.__field_unknown3=UINT(value,**{'sizeinbytes': 4})
2754 
2755     def __delfield_unknown3(self): del self.__field_unknown3
2756 
2757     unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None)
2758 
2759     def __getfield_timesent(self):
2760         return self.__field_timesent.getvalue()
2761 
2762     def __setfield_timesent(self, value):
2763         if isinstance(value,SMSDATE):
2764             self.__field_timesent=value
2765         else:
2766             self.__field_timesent=SMSDATE(value,**{'sizeinbytes': 6})
2767 
2768     def __delfield_timesent(self): del self.__field_timesent
2769 
2770     timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None)
2771 
2772     def __getfield_unknown(self):
2773         return self.__field_unknown.getvalue()
2774 
2775     def __setfield_unknown(self, value):
2776         if isinstance(value,UINT):
2777             self.__field_unknown=value
2778         else:
2779             self.__field_unknown=UINT(value,**{'sizeinbytes': 3})
2780 
2781     def __delfield_unknown(self): del self.__field_unknown
2782 
2783     unknown=property(__getfield_unknown, __setfield_unknown, __delfield_unknown, None)
2784 
2785     def __getfield_callback_length(self):
2786         return self.__field_callback_length.getvalue()
2787 
2788     def __setfield_callback_length(self, value):
2789         if isinstance(value,UINT):
2790             self.__field_callback_length=value
2791         else:
2792             self.__field_callback_length=UINT(value,**{'sizeinbytes': 1})
2793 
2794     def __delfield_callback_length(self): del self.__field_callback_length
2795 
2796     callback_length=property(__getfield_callback_length, __setfield_callback_length, __delfield_callback_length, None)
2797 
2798     def __getfield_callback(self):
2799         return self.__field_callback.getvalue()
2800 
2801     def __setfield_callback(self, value):
2802         if isinstance(value,USTRING):
2803             self.__field_callback=value
2804         else:
2805             self.__field_callback=USTRING(value,**{'sizeinbytes': 38})
2806 
2807     def __delfield_callback(self): del self.__field_callback
2808 
2809     callback=property(__getfield_callback, __setfield_callback, __delfield_callback, None)
2810 
2811     def __getfield_sender_length(self):
2812         return self.__field_sender_length.getvalue()
2813 
2814     def __setfield_sender_length(self, value):
2815         if isinstance(value,UINT):
2816             self.__field_sender_length=value
2817         else:
2818             self.__field_sender_length=UINT(value,**{'sizeinbytes': 1})
2819 
2820     def __delfield_sender_length(self): del self.__field_sender_length
2821 
2822     sender_length=property(__getfield_sender_length, __setfield_sender_length, __delfield_sender_length, None)
2823 
2824     def __getfield_sender(self):
2825         try: self.__field_sender
2826         except:
2827             self.__field_sender=LIST(**{'elementclass': _gen_p_lglx5450_235, 'length': 38})
2828         return self.__field_sender.getvalue()
2829 
2830     def __setfield_sender(self, value):
2831         if isinstance(value,LIST):
2832             self.__field_sender=value
2833         else:
2834             self.__field_sender=LIST(value,**{'elementclass': _gen_p_lglx5450_235, 'length': 38})
2835 
2836     def __delfield_sender(self): del self.__field_sender
2837 
2838     sender=property(__getfield_sender, __setfield_sender, __delfield_sender, None)
2839 
2840     def __getfield_unknown4(self):
2841         return self.__field_unknown4.getvalue()
2842 
2843     def __setfield_unknown4(self, value):
2844         if isinstance(value,DATA):
2845             self.__field_unknown4=value
2846         else:
2847             self.__field_unknown4=DATA(value,**{'sizeinbytes': 15})
2848 
2849     def __delfield_unknown4(self): del self.__field_unknown4
2850 
2851     unknown4=property(__getfield_unknown4, __setfield_unknown4, __delfield_unknown4, None)
2852 
2853     def __getfield_lg_time(self):
2854         return self.__field_lg_time.getvalue()
2855 
2856     def __setfield_lg_time(self, value):
2857         if isinstance(value,LGCALDATE):
2858             self.__field_lg_time=value
2859         else:
2860             self.__field_lg_time=LGCALDATE(value,**{'sizeinbytes': 4})
2861 
2862     def __delfield_lg_time(self): del self.__field_lg_time
2863 
2864     lg_time=property(__getfield_lg_time, __setfield_lg_time, __delfield_lg_time, None)
2865 
2866     def __getfield_GPStime(self):
2867         return self.__field_GPStime.getvalue()
2868 
2869     def __setfield_GPStime(self, value):
2870         if isinstance(value,GPSDATE):
2871             self.__field_GPStime=value
2872         else:
2873             self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4})
2874 
2875     def __delfield_GPStime(self): del self.__field_GPStime
2876 
2877     GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None)
2878 
2879     def __getfield_unknown5(self):
2880         return self.__field_unknown5.getvalue()
2881 
2882     def __setfield_unknown5(self, value):
2883         if isinstance(value,UINT):
2884             self.__field_unknown5=value
2885         else:
2886             self.__field_unknown5=UINT(value,**{'sizeinbytes': 2})
2887 
2888     def __delfield_unknown5(self): del self.__field_unknown5
2889 
2890     unknown5=property(__getfield_unknown5, __setfield_unknown5, __delfield_unknown5, None)
2891 
2892     def __getfield_read(self):
2893         return self.__field_read.getvalue()
2894 
2895     def __setfield_read(self, value):
2896         if isinstance(value,UINT):
2897             self.__field_read=value
2898         else:
2899             self.__field_read=UINT(value,**{'sizeinbytes': 1})
2900 
2901     def __delfield_read(self): del self.__field_read
2902 
2903     read=property(__getfield_read, __setfield_read, __delfield_read, None)
2904 
2905     def __getfield_locked(self):
2906         return self.__field_locked.getvalue()
2907 
2908     def __setfield_locked(self, value):
2909         if isinstance(value,UINT):
2910             self.__field_locked=value
2911         else:
2912             self.__field_locked=UINT(value,**{'sizeinbytes': 1})
2913 
2914     def __delfield_locked(self): del self.__field_locked
2915 
2916     locked=property(__getfield_locked, __setfield_locked, __delfield_locked, None)
2917 
2918     def __getfield_unknown8(self):
2919         return self.__field_unknown8.getvalue()
2920 
2921     def __setfield_unknown8(self, value):
2922         if isinstance(value,UINT):
2923             self.__field_unknown8=value
2924         else:
2925             self.__field_unknown8=UINT(value,**{'sizeinbytes': 2})
2926 
2927     def __delfield_unknown8(self): del self.__field_unknown8
2928 
2929     unknown8=property(__getfield_unknown8, __setfield_unknown8, __delfield_unknown8, None)
2930 
2931     def __getfield_priority(self):
2932         return self.__field_priority.getvalue()
2933 
2934     def __setfield_priority(self, value):
2935         if isinstance(value,UINT):
2936             self.__field_priority=value
2937         else:
2938             self.__field_priority=UINT(value,**{'sizeinbytes': 1})
2939 
2940     def __delfield_priority(self): del self.__field_priority
2941 
2942     priority=property(__getfield_priority, __setfield_priority, __delfield_priority, None)
2943 
2944     def __getfield_flags(self):
2945         return self.__field_flags.getvalue()
2946 
2947     def __setfield_flags(self, value):
2948         if isinstance(value,DATA):
2949             self.__field_flags=value
2950         else:
2951             self.__field_flags=DATA(value,**{'sizeinbytes': 5})
2952 
2953     def __delfield_flags(self): del self.__field_flags
2954 
2955     flags=property(__getfield_flags, __setfield_flags, __delfield_flags, None)
2956 
2957     def __getfield_subject(self):
2958         return self.__field_subject.getvalue()
2959 
2960     def __setfield_subject(self, value):
2961         if isinstance(value,USTRING):
2962             self.__field_subject=value
2963         else:
2964             self.__field_subject=USTRING(value,**{'sizeinbytes': 21, 'encoding': PHONE_ENCODING})
2965 
2966     def __delfield_subject(self): del self.__field_subject
2967 
2968     subject=property(__getfield_subject, __setfield_subject, __delfield_subject, None)
2969 
2970     def __getfield_bin_header1(self):
2971         return self.__field_bin_header1.getvalue()
2972 
2973     def __setfield_bin_header1(self, value):
2974         if isinstance(value,UINT):
2975             self.__field_bin_header1=value
2976         else:
2977             self.__field_bin_header1=UINT(value,**{'sizeinbytes': 1})
2978 
2979     def __delfield_bin_header1(self): del self.__field_bin_header1
2980 
2981     bin_header1=property(__getfield_bin_header1, __setfield_bin_header1, __delfield_bin_header1, None)
2982 
2983     def __getfield_bin_header2(self):
2984         return self.__field_bin_header2.getvalue()
2985 
2986     def __setfield_bin_header2(self, value):
2987         if isinstance(value,UINT):
2988             self.__field_bin_header2=value
2989         else:
2990             self.__field_bin_header2=UINT(value,**{'sizeinbytes': 1})
2991 
2992     def __delfield_bin_header2(self): del self.__field_bin_header2
2993 
2994     bin_header2=property(__getfield_bin_header2, __setfield_bin_header2, __delfield_bin_header2, None)
2995 
2996     def __getfield_unknown6(self):
2997         return self.__field_unknown6.getvalue()
2998 
2999     def __setfield_unknown6(self, value):
3000         if isinstance(value,UINT):
3001             self.__field_unknown6=value
3002         else:
3003             self.__field_unknown6=UINT(value,**{'sizeinbytes': 2})
3004 
3005     def __delfield_unknown6(self): del self.__field_unknown6
3006 
3007     unknown6=property(__getfield_unknown6, __setfield_unknown6, __delfield_unknown6, None)
3008 
3009     def __getfield_multipartID(self):
3010         return self.__field_multipartID.getvalue()
3011 
3012     def __setfield_multipartID(self, value):
3013         if isinstance(value,UINT):
3014             self.__field_multipartID=value
3015         else:
3016             self.__field_multipartID=UINT(value,**{'sizeinbytes': 2})
3017 
3018     def __delfield_multipartID(self): del self.__field_multipartID
3019 
3020     multipartID=property(__getfield_multipartID, __setfield_multipartID, __delfield_multipartID, None)
3021 
3022     def __getfield_bin_header3(self):
3023         return self.__field_bin_header3.getvalue()
3024 
3025     def __setfield_bin_header3(self, value):
3026         if isinstance(value,UINT):
3027             self.__field_bin_header3=value
3028         else:
3029             self.__field_bin_header3=UINT(value,**{'sizeinbytes': 1})
3030 
3031     def __delfield_bin_header3(self): del self.__field_bin_header3
3032 
3033     bin_header3=property(__getfield_bin_header3, __setfield_bin_header3, __delfield_bin_header3, None)
3034 
3035     def __getfield_num_msg_elements(self):
3036         return self.__field_num_msg_elements.getvalue()
3037 
3038     def __setfield_num_msg_elements(self, value):
3039         if isinstance(value,UINT):
3040             self.__field_num_msg_elements=value
3041         else:
3042             self.__field_num_msg_elements=UINT(value,**{'sizeinbytes': 1})
3043 
3044     def __delfield_num_msg_elements(self): del self.__field_num_msg_elements
3045 
3046     num_msg_elements=property(__getfield_num_msg_elements, __setfield_num_msg_elements, __delfield_num_msg_elements, None)
3047 
3048     def __getfield_msglengths(self):
3049         try: self.__field_msglengths
3050         except:
3051             self.__field_msglengths=LIST(**{'elementclass': _gen_p_lglx5450_253, 'length': 10})
3052         return self.__field_msglengths.getvalue()
3053 
3054     def __setfield_msglengths(self, value):
3055         if isinstance(value,LIST):
3056             self.__field_msglengths=value
3057         else:
3058             self.__field_msglengths=LIST(value,**{'elementclass': _gen_p_lglx5450_253, 'length': 10})
3059 
3060     def __delfield_msglengths(self): del self.__field_msglengths
3061 
3062     msglengths=property(__getfield_msglengths, __setfield_msglengths, __delfield_msglengths, None)
3063 
3064     def __getfield_msgs(self):
3065         try: self.__field_msgs
3066         except:
3067             self.__field_msgs=LIST(**{'length': 10, 'elementclass': SMSINBOXMSGFRAGMENT})
3068         return self.__field_msgs.getvalue()
3069 
3070     def __setfield_msgs(self, value):
3071         if isinstance(value,LIST):
3072             self.__field_msgs=value
3073         else:
3074             self.__field_msgs=LIST(value,**{'length': 10, 'elementclass': SMSINBOXMSGFRAGMENT})
3075 
3076     def __delfield_msgs(self): del self.__field_msgs
3077 
3078     msgs=property(__getfield_msgs, __setfield_msgs, __delfield_msgs, None)
3079 
3080     def __getfield_unknown5(self):
3081         return self.__field_unknown5.getvalue()
3082 
3083     def __setfield_unknown5(self, value):
3084         if isinstance(value,DATA):
3085             self.__field_unknown5=value
3086         else:
3087             self.__field_unknown5=DATA(value,**{'sizeinbytes': 437})
3088 
3089     def __delfield_unknown5(self): del self.__field_unknown5
3090 
3091     unknown5=property(__getfield_unknown5, __setfield_unknown5, __delfield_unknown5, None)
3092 
3093     def __getfield_senders_name(self):
3094         return self.__field_senders_name.getvalue()
3095 
3096     def __setfield_senders_name(self, value):
3097         if isinstance(value,USTRING):
3098             self.__field_senders_name=value
3099         else:
3100             self.__field_senders_name=USTRING(value,**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING})
3101 
3102     def __delfield_senders_name(self): del self.__field_senders_name
3103 
3104     senders_name=property(__getfield_senders_name, __setfield_senders_name, __delfield_senders_name, None)
3105 
3106     def __getfield_unknown6(self):
3107         return self.__field_unknown6.getvalue()
3108 
3109     def __setfield_unknown6(self, value):
3110         if isinstance(value,DATA):
3111             self.__field_unknown6=value
3112         else:
3113             self.__field_unknown6=DATA(value,**{'sizeinbytes': 169})
3114 
3115     def __delfield_unknown6(self): del self.__field_unknown6
3116 
3117     unknown6=property(__getfield_unknown6, __setfield_unknown6, __delfield_unknown6, None)
3118 
3119     def iscontainer(self):
3120         return True
3121 
3122     def containerelements(self):
3123         yield ('msg_index1', self.__field_msg_index1, None)
3124         yield ('msg_index2', self.__field_msg_index2, None)
3125         yield ('unknown2', self.__field_unknown2, None)
3126         yield ('unknown3', self.__field_unknown3, None)
3127         yield ('timesent', self.__field_timesent, None)
3128         yield ('unknown', self.__field_unknown, None)
3129         yield ('callback_length', self.__field_callback_length, None)
3130         yield ('callback', self.__field_callback, None)
3131         yield ('sender_length', self.__field_sender_length, None)
3132         yield ('sender', self.__field_sender, None)
3133         yield ('unknown4', self.__field_unknown4, None)
3134         yield ('lg_time', self.__field_lg_time, None)
3135         yield ('GPStime', self.__field_GPStime, None)
3136         yield ('unknown5', self.__field_unknown5, None)
3137         yield ('read', self.__field_read, None)
3138         yield ('locked', self.__field_locked, None)
3139         yield ('unknown8', self.__field_unknown8, None)
3140         yield ('priority', self.__field_priority, None)
3141         yield ('flags', self.__field_flags, None)
3142         yield ('subject', self.__field_subject, None)
3143         yield ('bin_header1', self.__field_bin_header1, None)
3144         yield ('bin_header2', self.__field_bin_header2, None)
3145         yield ('unknown6', self.__field_unknown6, None)
3146         yield ('multipartID', self.__field_multipartID, None)
3147         yield ('bin_header3', self.__field_bin_header3, None)
3148         yield ('num_msg_elements', self.__field_num_msg_elements, None)
3149         yield ('msglengths', self.__field_msglengths, None)
3150         yield ('msgs', self.__field_msgs, None)
3151         yield ('unknown5', self.__field_unknown5, None)
3152         yield ('senders_name', self.__field_senders_name, None)
3153         yield ('unknown6', self.__field_unknown6, None)
3154 
3155 
3156 
3157 
3158 class _gen_p_lglx5450_235(BaseProtogenClass):
3159     'Anonymous inner class'
3160     __fields=['byte']
3161 
3162     def __init__(self, *args, **kwargs):
3163         dict={}
3164         # What was supplied to this function
3165         dict.update(kwargs)
3166         # Parent constructor
3167         super(_gen_p_lglx5450_235,self).__init__(**dict)
3168         if self.__class__ is _gen_p_lglx5450_235:
3169             self._update(args,dict)
3170 
3171 
3172     def getfields(self):
3173         return self.__fields
3174 
3175 
3176     def _update(self, args, kwargs):
3177         super(_gen_p_lglx5450_235,self)._update(args,kwargs)
3178         keys=kwargs.keys()
3179         for key in keys:
3180             if key in self.__fields:
3181                 setattr(self, key, kwargs[key])
3182                 del kwargs[key]
3183         # Were any unrecognized kwargs passed in?
3184         if __debug__:
3185             self._complainaboutunusedargs(_gen_p_lglx5450_235,kwargs)
3186         if len(args):
3187             dict2={'sizeinbytes': 1}
3188             dict2.update(kwargs)
3189             kwargs=dict2
3190             self.__field_byte=UINT(*args,**dict2)
3191         # Make all P fields that haven't already been constructed
3192 
3193 
3194     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3195         'Writes this packet to the supplied buffer'
3196         self._bufferstartoffset=buf.getcurrentoffset()
3197         self.__field_byte.writetobuffer(buf)
3198         self._bufferendoffset=buf.getcurrentoffset()
3199         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3200 
3201 
3202     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3203         'Reads this packet from the supplied buffer'
3204         self._bufferstartoffset=buf.getcurrentoffset()
3205         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3206         self.__field_byte=UINT(**{'sizeinbytes': 1})
3207         self.__field_byte.readfrombuffer(buf)
3208         self._bufferendoffset=buf.getcurrentoffset()
3209 
3210 
3211     def __getfield_byte(self):
3212         return self.__field_byte.getvalue()
3213 
3214     def __setfield_byte(self, value):
3215         if isinstance(value,UINT):
3216             self.__field_byte=value
3217         else:
3218             self.__field_byte=UINT(value,**{'sizeinbytes': 1})
3219 
3220     def __delfield_byte(self): del self.__field_byte
3221 
3222     byte=property(__getfield_byte, __setfield_byte, __delfield_byte, "individual byte of senders phone number")
3223 
3224     def iscontainer(self):
3225         return True
3226 
3227     def containerelements(self):
3228         yield ('byte', self.__field_byte, "individual byte of senders phone number")
3229 
3230 
3231 
3232 
3233 class _gen_p_lglx5450_253(BaseProtogenClass):
3234     'Anonymous inner class'
3235     __fields=['msglength']
3236 
3237     def __init__(self, *args, **kwargs):
3238         dict={}
3239         # What was supplied to this function
3240         dict.update(kwargs)
3241         # Parent constructor
3242         super(_gen_p_lglx5450_253,self).__init__(**dict)
3243         if self.__class__ is _gen_p_lglx5450_253:
3244             self._update(args,dict)
3245 
3246 
3247     def getfields(self):
3248         return self.__fields
3249 
3250 
3251     def _update(self, args, kwargs):
3252         super(_gen_p_lglx5450_253,self)._update(args,kwargs)
3253         keys=kwargs.keys()
3254         for key in keys:
3255             if key in self.__fields:
3256                 setattr(self, key, kwargs[key])
3257                 del kwargs[key]
3258         # Were any unrecognized kwargs passed in?
3259         if __debug__:
3260             self._complainaboutunusedargs(_gen_p_lglx5450_253,kwargs)
3261         if len(args):
3262             dict2={'sizeinbytes': 1}
3263             dict2.update(kwargs)
3264             kwargs=dict2
3265             self.__field_msglength=UINT(*args,**dict2)
3266         # Make all P fields that haven't already been constructed
3267 
3268 
3269     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3270         'Writes this packet to the supplied buffer'
3271         self._bufferstartoffset=buf.getcurrentoffset()
3272         self.__field_msglength.writetobuffer(buf)
3273         self._bufferendoffset=buf.getcurrentoffset()
3274         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3275 
3276 
3277     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3278         'Reads this packet from the supplied buffer'
3279         self._bufferstartoffset=buf.getcurrentoffset()
3280         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3281         self.__field_msglength=UINT(**{'sizeinbytes': 1})
3282         self.__field_msglength.readfrombuffer(buf)
3283         self._bufferendoffset=buf.getcurrentoffset()
3284 
3285 
3286     def __getfield_msglength(self):
3287         return self.__field_msglength.getvalue()
3288 
3289     def __setfield_msglength(self, value):
3290         if isinstance(value,UINT):
3291             self.__field_msglength=value
3292         else:
3293             self.__field_msglength=UINT(value,**{'sizeinbytes': 1})
3294 
3295     def __delfield_msglength(self): del self.__field_msglength
3296 
3297     msglength=property(__getfield_msglength, __setfield_msglength, __delfield_msglength, "lengths of individual messages in septets")
3298 
3299     def iscontainer(self):
3300         return True
3301 
3302     def containerelements(self):
3303         yield ('msglength', self.__field_msglength, "lengths of individual messages in septets")
3304 
3305 
3306 
3307 
3308 class sms_quick_text(BaseProtogenClass):
3309     __fields=['msgs']
3310 
3311     def __init__(self, *args, **kwargs):
3312         dict={}
3313         # What was supplied to this function
3314         dict.update(kwargs)
3315         # Parent constructor
3316         super(sms_quick_text,self).__init__(**dict)
3317         if self.__class__ is sms_quick_text:
3318             self._update(args,dict)
3319 
3320 
3321     def getfields(self):
3322         return self.__fields
3323 
3324 
3325     def _update(self, args, kwargs):
3326         super(sms_quick_text,self)._update(args,kwargs)
3327         keys=kwargs.keys()
3328         for key in keys:
3329             if key in self.__fields:
3330                 setattr(self, key, kwargs[key])
3331                 del kwargs[key]
3332         # Were any unrecognized kwargs passed in?
3333         if __debug__:
3334             self._complainaboutunusedargs(sms_quick_text,kwargs)
3335         if len(args):
3336             dict2={'elementclass': _gen_p_lglx5450_269, }
3337             dict2.update(kwargs)
3338             kwargs=dict2
3339             self.__field_msgs=LIST(*args,**dict2)
3340         # Make all P fields that haven't already been constructed
3341 
3342 
3343     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3344         'Writes this packet to the supplied buffer'
3345         self._bufferstartoffset=buf.getcurrentoffset()
3346         try: self.__field_msgs
3347         except:
3348             self.__field_msgs=LIST(**{'elementclass': _gen_p_lglx5450_269, })
3349         self.__field_msgs.writetobuffer(buf)
3350         self._bufferendoffset=buf.getcurrentoffset()
3351         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3352 
3353 
3354     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3355         'Reads this packet from the supplied buffer'
3356         self._bufferstartoffset=buf.getcurrentoffset()
3357         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3358         self.__field_msgs=LIST(**{'elementclass': _gen_p_lglx5450_269, })
3359         self.__field_msgs.readfrombuffer(buf)
3360         self._bufferendoffset=buf.getcurrentoffset()
3361 
3362 
3363     def __getfield_msgs(self):
3364         try: self.__field_msgs
3365         except:
3366             self.__field_msgs=LIST(**{'elementclass': _gen_p_lglx5450_269, })
3367         return self.__field_msgs.getvalue()
3368 
3369     def __setfield_msgs(self, value):
3370         if isinstance(value,LIST):
3371             self.__field_msgs=value
3372         else:
3373             self.__field_msgs=LIST(value,**{'elementclass': _gen_p_lglx5450_269, })
3374 
3375     def __delfield_msgs(self): del self.__field_msgs
3376 
3377     msgs=property(__getfield_msgs, __setfield_msgs, __delfield_msgs, None)
3378 
3379     def iscontainer(self):
3380         return True
3381 
3382     def containerelements(self):
3383         yield ('msgs', self.__field_msgs, None)
3384 
3385 
3386 
3387 
3388 class _gen_p_lglx5450_269(BaseProtogenClass):
3389     'Anonymous inner class'
3390     __fields=['msg']
3391 
3392     def __init__(self, *args, **kwargs):
3393         dict={}
3394         # What was supplied to this function
3395         dict.update(kwargs)
3396         # Parent constructor
3397         super(_gen_p_lglx5450_269,self).__init__(**dict)
3398         if self.__class__ is _gen_p_lglx5450_269:
3399             self._update(args,dict)
3400 
3401 
3402     def getfields(self):
3403         return self.__fields
3404 
3405 
3406     def _update(self, args, kwargs):
3407         super(_gen_p_lglx5450_269,self)._update(args,kwargs)
3408         keys=kwargs.keys()
3409         for key in keys:
3410             if key in self.__fields:
3411                 setattr(self, key, kwargs[key])
3412                 del kwargs[key]
3413         # Were any unrecognized kwargs passed in?
3414         if __debug__:
3415             self._complainaboutunusedargs(_gen_p_lglx5450_269,kwargs)
3416         if len(args):
3417             dict2={'encoding': PHONE_ENCODING}
3418             dict2.update(kwargs)
3419             kwargs=dict2
3420             self.__field_msg=USTRING(*args,**dict2)
3421         # Make all P fields that haven't already been constructed
3422 
3423 
3424     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3425         'Writes this packet to the supplied buffer'
3426         self._bufferstartoffset=buf.getcurrentoffset()
3427         self.__field_msg.writetobuffer(buf)
3428         self._bufferendoffset=buf.getcurrentoffset()
3429         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3430 
3431 
3432     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3433         'Reads this packet from the supplied buffer'
3434         self._bufferstartoffset=buf.getcurrentoffset()
3435         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3436         self.__field_msg=USTRING(**{'encoding': PHONE_ENCODING})
3437         self.__field_msg.readfrombuffer(buf)
3438         self._bufferendoffset=buf.getcurrentoffset()
3439 
3440 
3441     def __getfield_msg(self):
3442         return self.__field_msg.getvalue()
3443 
3444     def __setfield_msg(self, value):
3445         if isinstance(value,USTRING):
3446             self.__field_msg=value
3447         else:
3448             self.__field_msg=USTRING(value,**{'encoding': PHONE_ENCODING})
3449 
3450     def __delfield_msg(self): del self.__field_msg
3451 
3452     msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None)
3453 
3454     def iscontainer(self):
3455         return True
3456 
3457     def containerelements(self):
3458         yield ('msg', self.__field_msg, None)
3459 
3460 
3461 
3462 
3463