PyXR

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

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