PyXR

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

0001 # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE
0002 ##from common import PhoneBookBusyException
0003 
0004 from p_lgvx9900 import *
0005  
0006 from prototypes import *
0007 from prototypeslg import *
0008  
0009 # Make all lg stuff available in this module as well
0010 from p_lg import *
0011 from p_brew import *
0012 
0013 # We use LSB for all integer like fields
0014 UINT=UINTlsb
0015 BOOL=BOOLlsb
0016 
0017 BREW_FILE_SYSTEM=2
0018 NOMSGRINGTONE=1
0019 NUMSPEEDDIALS=100
0020 FIRSTSPEEDDIAL=2
0021 LASTSPEEDDIAL=99
0022 NUMPHONEBOOKENTRIES=500
0023 pb_file_name='pim/pbentry.dat'
0024 
0025 
0026 PHONE_ENCODING='iso-8859-1'
0027 
0028 
0029 # Media type
0030 MEDIA_TYPE_RINGTONE=0x0201
0031 MEDIA_TYPE_IMAGE=0x400
0032 MEDIA_TYPE_SOUND=0x0402
0033 MEDIA_TYPE_SDIMAGE=0x0008
0034 MEDIA_TYPE_SDSOUND=0x000C
0035 MEDIA_TYPE_VIDEO=0x0304
0036 MEDIA_RINGTONE_DEFAULT_ICON=1
0037 MEDIA_IMAGE_DEFAULT_ICON=0
0038 MEDIA_VIDEO_DEFAULT_ICON=0
0039 
0040 # need to call stat to get the file time/data
0041 broken_filelist_date=True
0042  # Calendar parameters
0043 NUMCALENDARENTRIES=300
0044 # vx8100 uses a type based index for speed dials instead of positional like the vx4400
0045 SPEEDDIALINDEX=1 
0046 MAXCALENDARDESCRIPTION=32
0047 
0048 CALENDAR_HAS_SEPARATE_END_TIME_AND_DATE=0
0049 class LockKeyReq(BaseProtogenClass):
0050     __fields=['cmd', 'lock']
0051 
0052     def __init__(self, *args, **kwargs):
0053         dict={}
0054         # What was supplied to this function
0055         dict.update(kwargs)
0056         # Parent constructor
0057         super(LockKeyReq,self).__init__(**dict)
0058         if self.__class__ is LockKeyReq:
0059             self._update(args,dict)
0060 
0061 
0062     def getfields(self):
0063         return self.__fields
0064 
0065 
0066     def _update(self, args, kwargs):
0067         super(LockKeyReq,self)._update(args,kwargs)
0068         keys=kwargs.keys()
0069         for key in keys:
0070             if key in self.__fields:
0071                 setattr(self, key, kwargs[key])
0072                 del kwargs[key]
0073         # Were any unrecognized kwargs passed in?
0074         if __debug__:
0075             self._complainaboutunusedargs(LockKeyReq,kwargs)
0076         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0077         # Make all P fields that haven't already been constructed
0078 
0079 
0080     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0081         'Writes this packet to the supplied buffer'
0082         self._bufferstartoffset=buf.getcurrentoffset()
0083         try: self.__field_cmd
0084         except:
0085             self.__field_cmd=UINT(**{'sizeinbytes': 1,  'default': 0x21 })
0086         self.__field_cmd.writetobuffer(buf)
0087         try: self.__field_lock
0088         except:
0089             self.__field_lock=UINT(**{'sizeinbytes': 2,  'default': 0 })
0090         self.__field_lock.writetobuffer(buf)
0091         self._bufferendoffset=buf.getcurrentoffset()
0092         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0093 
0094 
0095     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0096         'Reads this packet from the supplied buffer'
0097         self._bufferstartoffset=buf.getcurrentoffset()
0098         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0099         self.__field_cmd=UINT(**{'sizeinbytes': 1,  'default': 0x21 })
0100         self.__field_cmd.readfrombuffer(buf)
0101         self.__field_lock=UINT(**{'sizeinbytes': 2,  'default': 0 })
0102         self.__field_lock.readfrombuffer(buf)
0103         self._bufferendoffset=buf.getcurrentoffset()
0104 
0105 
0106     def __getfield_cmd(self):
0107         try: self.__field_cmd
0108         except:
0109             self.__field_cmd=UINT(**{'sizeinbytes': 1,  'default': 0x21 })
0110         return self.__field_cmd.getvalue()
0111 
0112     def __setfield_cmd(self, value):
0113         if isinstance(value,UINT):
0114             self.__field_cmd=value
0115         else:
0116             self.__field_cmd=UINT(value,**{'sizeinbytes': 1,  'default': 0x21 })
0117 
0118     def __delfield_cmd(self): del self.__field_cmd
0119 
0120     cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None)
0121 
0122     def __getfield_lock(self):
0123         try: self.__field_lock
0124         except:
0125             self.__field_lock=UINT(**{'sizeinbytes': 2,  'default': 0 })
0126         return self.__field_lock.getvalue()
0127 
0128     def __setfield_lock(self, value):
0129         if isinstance(value,UINT):
0130             self.__field_lock=value
0131         else:
0132             self.__field_lock=UINT(value,**{'sizeinbytes': 2,  'default': 0 })
0133 
0134     def __delfield_lock(self): del self.__field_lock
0135 
0136     lock=property(__getfield_lock, __setfield_lock, __delfield_lock, "0=Lock, 1=Unlock")
0137 
0138     def iscontainer(self):
0139         return True
0140 
0141     def containerelements(self):
0142         yield ('cmd', self.__field_cmd, None)
0143         yield ('lock', self.__field_lock, "0=Lock, 1=Unlock")
0144 
0145 
0146 
0147 
0148 class KeyPressReq(BaseProtogenClass):
0149     __fields=['cmd', 'hold', 'key']
0150 
0151     def __init__(self, *args, **kwargs):
0152         dict={}
0153         # What was supplied to this function
0154         dict.update(kwargs)
0155         # Parent constructor
0156         super(KeyPressReq,self).__init__(**dict)
0157         if self.__class__ is KeyPressReq:
0158             self._update(args,dict)
0159 
0160 
0161     def getfields(self):
0162         return self.__fields
0163 
0164 
0165     def _update(self, args, kwargs):
0166         super(KeyPressReq,self)._update(args,kwargs)
0167         keys=kwargs.keys()
0168         for key in keys:
0169             if key in self.__fields:
0170                 setattr(self, key, kwargs[key])
0171                 del kwargs[key]
0172         # Were any unrecognized kwargs passed in?
0173         if __debug__:
0174             self._complainaboutunusedargs(KeyPressReq,kwargs)
0175         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0176         # Make all P fields that haven't already been constructed
0177 
0178 
0179     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0180         'Writes this packet to the supplied buffer'
0181         self._bufferstartoffset=buf.getcurrentoffset()
0182         try: self.__field_cmd
0183         except:
0184             self.__field_cmd=UINT(**{'sizeinbytes': 1,  'default': 0x20 })
0185         self.__field_cmd.writetobuffer(buf)
0186         try: self.__field_hold
0187         except:
0188             self.__field_hold=UINT(**{'sizeinbytes': 1,  'default': 0 })
0189         self.__field_hold.writetobuffer(buf)
0190         self.__field_key.writetobuffer(buf)
0191         self._bufferendoffset=buf.getcurrentoffset()
0192         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0193 
0194 
0195     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0196         'Reads this packet from the supplied buffer'
0197         self._bufferstartoffset=buf.getcurrentoffset()
0198         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0199         self.__field_cmd=UINT(**{'sizeinbytes': 1,  'default': 0x20 })
0200         self.__field_cmd.readfrombuffer(buf)
0201         self.__field_hold=UINT(**{'sizeinbytes': 1,  'default': 0 })
0202         self.__field_hold.readfrombuffer(buf)
0203         self.__field_key=STRING(**{'sizeinbytes': 1,  'terminator': None,                'sizeinbytes': 1 })
0204         self.__field_key.readfrombuffer(buf)
0205         self._bufferendoffset=buf.getcurrentoffset()
0206 
0207 
0208     def __getfield_cmd(self):
0209         try: self.__field_cmd
0210         except:
0211             self.__field_cmd=UINT(**{'sizeinbytes': 1,  'default': 0x20 })
0212         return self.__field_cmd.getvalue()
0213 
0214     def __setfield_cmd(self, value):
0215         if isinstance(value,UINT):
0216             self.__field_cmd=value
0217         else:
0218             self.__field_cmd=UINT(value,**{'sizeinbytes': 1,  'default': 0x20 })
0219 
0220     def __delfield_cmd(self): del self.__field_cmd
0221 
0222     cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None)
0223 
0224     def __getfield_hold(self):
0225         try: self.__field_hold
0226         except:
0227             self.__field_hold=UINT(**{'sizeinbytes': 1,  'default': 0 })
0228         return self.__field_hold.getvalue()
0229 
0230     def __setfield_hold(self, value):
0231         if isinstance(value,UINT):
0232             self.__field_hold=value
0233         else:
0234             self.__field_hold=UINT(value,**{'sizeinbytes': 1,  'default': 0 })
0235 
0236     def __delfield_hold(self): del self.__field_hold
0237 
0238     hold=property(__getfield_hold, __setfield_hold, __delfield_hold, None)
0239 
0240     def __getfield_key(self):
0241         return self.__field_key.getvalue()
0242 
0243     def __setfield_key(self, value):
0244         if isinstance(value,STRING):
0245             self.__field_key=value
0246         else:
0247             self.__field_key=STRING(value,**{'sizeinbytes': 1,  'terminator': None,                'sizeinbytes': 1 })
0248 
0249     def __delfield_key(self): del self.__field_key
0250 
0251     key=property(__getfield_key, __setfield_key, __delfield_key, None)
0252 
0253     def iscontainer(self):
0254         return True
0255 
0256     def containerelements(self):
0257         yield ('cmd', self.__field_cmd, None)
0258         yield ('hold', self.__field_hold, None)
0259         yield ('key', self.__field_key, None)
0260 
0261 
0262 
0263 
0264 class indexentry(BaseProtogenClass):
0265     __fields=['index', 'type', 'filename', 'icon', 'date', 'dunno', 'size', 'dunno1']
0266 
0267     def __init__(self, *args, **kwargs):
0268         dict={}
0269         # What was supplied to this function
0270         dict.update(kwargs)
0271         # Parent constructor
0272         super(indexentry,self).__init__(**dict)
0273         if self.__class__ is indexentry:
0274             self._update(args,dict)
0275 
0276 
0277     def getfields(self):
0278         return self.__fields
0279 
0280 
0281     def _update(self, args, kwargs):
0282         super(indexentry,self)._update(args,kwargs)
0283         keys=kwargs.keys()
0284         for key in keys:
0285             if key in self.__fields:
0286                 setattr(self, key, kwargs[key])
0287                 del kwargs[key]
0288         # Were any unrecognized kwargs passed in?
0289         if __debug__:
0290             self._complainaboutunusedargs(indexentry,kwargs)
0291         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0292         # Make all P fields that haven't already been constructed
0293 
0294 
0295     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0296         'Writes this packet to the supplied buffer'
0297         self._bufferstartoffset=buf.getcurrentoffset()
0298         self.__field_index.writetobuffer(buf)
0299         self.__field_type.writetobuffer(buf)
0300         self.__field_filename.writetobuffer(buf)
0301         try: self.__field_icon
0302         except:
0303             self.__field_icon=UINT(**{'sizeinbytes': 4, 'default':0})
0304         self.__field_icon.writetobuffer(buf)
0305         try: self.__field_date
0306         except:
0307             self.__field_date=UINT(**{'sizeinbytes': 4, 'default': 0})
0308         self.__field_date.writetobuffer(buf)
0309         self.__field_dunno.writetobuffer(buf)
0310         try: self.__field_size
0311         except:
0312             self.__field_size=UINT(**{'sizeinbytes': 4, 'default': 0})
0313         self.__field_size.writetobuffer(buf)
0314         self.__field_dunno1.writetobuffer(buf)
0315         self._bufferendoffset=buf.getcurrentoffset()
0316         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0317 
0318 
0319     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0320         'Reads this packet from the supplied buffer'
0321         self._bufferstartoffset=buf.getcurrentoffset()
0322         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0323         self.__field_index=UINT(**{'sizeinbytes': 2})
0324         self.__field_index.readfrombuffer(buf)
0325         self.__field_type=UINT(**{'sizeinbytes': 2})
0326         self.__field_type.readfrombuffer(buf)
0327         self.__field_filename=USTRING(**{'sizeinbytes': 256, 'encoding': PHONE_ENCODING,                'raiseonunterminatedread': False,                'raiseontruncate': False })
0328         self.__field_filename.readfrombuffer(buf)
0329         self.__field_icon=UINT(**{'sizeinbytes': 4, 'default':0})
0330         self.__field_icon.readfrombuffer(buf)
0331         self.__field_date=UINT(**{'sizeinbytes': 4, 'default': 0})
0332         self.__field_date.readfrombuffer(buf)
0333         self.__field_dunno=UINT(**{'sizeinbytes': 4})
0334         self.__field_dunno.readfrombuffer(buf)
0335         self.__field_size=UINT(**{'sizeinbytes': 4, 'default': 0})
0336         self.__field_size.readfrombuffer(buf)
0337         self.__field_dunno1=UINT(**{'sizeinbytes': 4})
0338         self.__field_dunno1.readfrombuffer(buf)
0339         self._bufferendoffset=buf.getcurrentoffset()
0340 
0341 
0342     def __getfield_index(self):
0343         return self.__field_index.getvalue()
0344 
0345     def __setfield_index(self, value):
0346         if isinstance(value,UINT):
0347             self.__field_index=value
0348         else:
0349             self.__field_index=UINT(value,**{'sizeinbytes': 2})
0350 
0351     def __delfield_index(self): del self.__field_index
0352 
0353     index=property(__getfield_index, __setfield_index, __delfield_index, None)
0354 
0355     def __getfield_type(self):
0356         return self.__field_type.getvalue()
0357 
0358     def __setfield_type(self, value):
0359         if isinstance(value,UINT):
0360             self.__field_type=value
0361         else:
0362             self.__field_type=UINT(value,**{'sizeinbytes': 2})
0363 
0364     def __delfield_type(self): del self.__field_type
0365 
0366     type=property(__getfield_type, __setfield_type, __delfield_type, None)
0367 
0368     def __getfield_filename(self):
0369         return self.__field_filename.getvalue()
0370 
0371     def __setfield_filename(self, value):
0372         if isinstance(value,USTRING):
0373             self.__field_filename=value
0374         else:
0375             self.__field_filename=USTRING(value,**{'sizeinbytes': 256, 'encoding': PHONE_ENCODING,                'raiseonunterminatedread': False,                'raiseontruncate': False })
0376 
0377     def __delfield_filename(self): del self.__field_filename
0378 
0379     filename=property(__getfield_filename, __setfield_filename, __delfield_filename, "includes full pathname")
0380 
0381     def __getfield_icon(self):
0382         try: self.__field_icon
0383         except:
0384             self.__field_icon=UINT(**{'sizeinbytes': 4, 'default':0})
0385         return self.__field_icon.getvalue()
0386 
0387     def __setfield_icon(self, value):
0388         if isinstance(value,UINT):
0389             self.__field_icon=value
0390         else:
0391             self.__field_icon=UINT(value,**{'sizeinbytes': 4, 'default':0})
0392 
0393     def __delfield_icon(self): del self.__field_icon
0394 
0395     icon=property(__getfield_icon, __setfield_icon, __delfield_icon, None)
0396 
0397     def __getfield_date(self):
0398         try: self.__field_date
0399         except:
0400             self.__field_date=UINT(**{'sizeinbytes': 4, 'default': 0})
0401         return self.__field_date.getvalue()
0402 
0403     def __setfield_date(self, value):
0404         if isinstance(value,UINT):
0405             self.__field_date=value
0406         else:
0407             self.__field_date=UINT(value,**{'sizeinbytes': 4, 'default': 0})
0408 
0409     def __delfield_date(self): del self.__field_date
0410 
0411     date=property(__getfield_date, __setfield_date, __delfield_date, "i think this is bitfield of the date")
0412 
0413     def __getfield_dunno(self):
0414         return self.__field_dunno.getvalue()
0415 
0416     def __setfield_dunno(self, value):
0417         if isinstance(value,UINT):
0418             self.__field_dunno=value
0419         else:
0420             self.__field_dunno=UINT(value,**{'sizeinbytes': 4})
0421 
0422     def __delfield_dunno(self): del self.__field_dunno
0423 
0424     dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, None)
0425 
0426     def __getfield_size(self):
0427         try: self.__field_size
0428         except:
0429             self.__field_size=UINT(**{'sizeinbytes': 4, 'default': 0})
0430         return self.__field_size.getvalue()
0431 
0432     def __setfield_size(self, value):
0433         if isinstance(value,UINT):
0434             self.__field_size=value
0435         else:
0436             self.__field_size=UINT(value,**{'sizeinbytes': 4, 'default': 0})
0437 
0438     def __delfield_size(self): del self.__field_size
0439 
0440     size=property(__getfield_size, __setfield_size, __delfield_size, "size of the file, can be set to zero")
0441 
0442     def __getfield_dunno1(self):
0443         return self.__field_dunno1.getvalue()
0444 
0445     def __setfield_dunno1(self, value):
0446         if isinstance(value,UINT):
0447             self.__field_dunno1=value
0448         else:
0449             self.__field_dunno1=UINT(value,**{'sizeinbytes': 4})
0450 
0451     def __delfield_dunno1(self): del self.__field_dunno1
0452 
0453     dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None)
0454 
0455     def iscontainer(self):
0456         return True
0457 
0458     def containerelements(self):
0459         yield ('index', self.__field_index, None)
0460         yield ('type', self.__field_type, None)
0461         yield ('filename', self.__field_filename, "includes full pathname")
0462         yield ('icon', self.__field_icon, None)
0463         yield ('date', self.__field_date, "i think this is bitfield of the date")
0464         yield ('dunno', self.__field_dunno, None)
0465         yield ('size', self.__field_size, "size of the file, can be set to zero")
0466         yield ('dunno1', self.__field_dunno1, None)
0467 
0468 
0469 
0470 
0471 class indexfile(BaseProtogenClass):
0472     "Used for tracking wallpaper and ringtones"
0473     __fields=['items']
0474 
0475     def __init__(self, *args, **kwargs):
0476         dict={}
0477         # What was supplied to this function
0478         dict.update(kwargs)
0479         # Parent constructor
0480         super(indexfile,self).__init__(**dict)
0481         if self.__class__ is indexfile:
0482             self._update(args,dict)
0483 
0484 
0485     def getfields(self):
0486         return self.__fields
0487 
0488 
0489     def _update(self, args, kwargs):
0490         super(indexfile,self)._update(args,kwargs)
0491         keys=kwargs.keys()
0492         for key in keys:
0493             if key in self.__fields:
0494                 setattr(self, key, kwargs[key])
0495                 del kwargs[key]
0496         # Were any unrecognized kwargs passed in?
0497         if __debug__:
0498             self._complainaboutunusedargs(indexfile,kwargs)
0499         if len(args):
0500             dict2={'elementclass': indexentry, 'createdefault': True}
0501             dict2.update(kwargs)
0502             kwargs=dict2
0503             self.__field_items=LIST(*args,**dict2)
0504         # Make all P fields that haven't already been constructed
0505 
0506 
0507     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0508         'Writes this packet to the supplied buffer'
0509         self._bufferstartoffset=buf.getcurrentoffset()
0510         try: self.__field_items
0511         except:
0512             self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True})
0513         self.__field_items.writetobuffer(buf)
0514         self._bufferendoffset=buf.getcurrentoffset()
0515         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0516 
0517 
0518     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0519         'Reads this packet from the supplied buffer'
0520         self._bufferstartoffset=buf.getcurrentoffset()
0521         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0522         self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True})
0523         self.__field_items.readfrombuffer(buf)
0524         self._bufferendoffset=buf.getcurrentoffset()
0525 
0526 
0527     def __getfield_items(self):
0528         try: self.__field_items
0529         except:
0530             self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True})
0531         return self.__field_items.getvalue()
0532 
0533     def __setfield_items(self, value):
0534         if isinstance(value,LIST):
0535             self.__field_items=value
0536         else:
0537             self.__field_items=LIST(value,**{'elementclass': indexentry, 'createdefault': True})
0538 
0539     def __delfield_items(self): del self.__field_items
0540 
0541     items=property(__getfield_items, __setfield_items, __delfield_items, None)
0542 
0543     def iscontainer(self):
0544         return True
0545 
0546     def containerelements(self):
0547         yield ('items', self.__field_items, None)
0548 
0549 
0550 
0551 
0552 class speeddial(BaseProtogenClass):
0553     __fields=['entry', 'number']
0554 
0555     def __init__(self, *args, **kwargs):
0556         dict={}
0557         # What was supplied to this function
0558         dict.update(kwargs)
0559         # Parent constructor
0560         super(speeddial,self).__init__(**dict)
0561         if self.__class__ is speeddial:
0562             self._update(args,dict)
0563 
0564 
0565     def getfields(self):
0566         return self.__fields
0567 
0568 
0569     def _update(self, args, kwargs):
0570         super(speeddial,self)._update(args,kwargs)
0571         keys=kwargs.keys()
0572         for key in keys:
0573             if key in self.__fields:
0574                 setattr(self, key, kwargs[key])
0575                 del kwargs[key]
0576         # Were any unrecognized kwargs passed in?
0577         if __debug__:
0578             self._complainaboutunusedargs(speeddial,kwargs)
0579         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0580         # Make all P fields that haven't already been constructed
0581 
0582 
0583     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0584         'Writes this packet to the supplied buffer'
0585         self._bufferstartoffset=buf.getcurrentoffset()
0586         try: self.__field_entry
0587         except:
0588             self.__field_entry=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
0589         self.__field_entry.writetobuffer(buf)
0590         try: self.__field_number
0591         except:
0592             self.__field_number=UINT(**{'sizeinbytes': 1, 'default': 0xff})
0593         self.__field_number.writetobuffer(buf)
0594         self._bufferendoffset=buf.getcurrentoffset()
0595         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0596 
0597 
0598     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0599         'Reads this packet from the supplied buffer'
0600         self._bufferstartoffset=buf.getcurrentoffset()
0601         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0602         self.__field_entry=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
0603         self.__field_entry.readfrombuffer(buf)
0604         self.__field_number=UINT(**{'sizeinbytes': 1, 'default': 0xff})
0605         self.__field_number.readfrombuffer(buf)
0606         self._bufferendoffset=buf.getcurrentoffset()
0607 
0608 
0609     def __getfield_entry(self):
0610         try: self.__field_entry
0611         except:
0612             self.__field_entry=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
0613         return self.__field_entry.getvalue()
0614 
0615     def __setfield_entry(self, value):
0616         if isinstance(value,UINT):
0617             self.__field_entry=value
0618         else:
0619             self.__field_entry=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff})
0620 
0621     def __delfield_entry(self): del self.__field_entry
0622 
0623     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
0624 
0625     def __getfield_number(self):
0626         try: self.__field_number
0627         except:
0628             self.__field_number=UINT(**{'sizeinbytes': 1, 'default': 0xff})
0629         return self.__field_number.getvalue()
0630 
0631     def __setfield_number(self, value):
0632         if isinstance(value,UINT):
0633             self.__field_number=value
0634         else:
0635             self.__field_number=UINT(value,**{'sizeinbytes': 1, 'default': 0xff})
0636 
0637     def __delfield_number(self): del self.__field_number
0638 
0639     number=property(__getfield_number, __setfield_number, __delfield_number, None)
0640 
0641     def iscontainer(self):
0642         return True
0643 
0644     def containerelements(self):
0645         yield ('entry', self.__field_entry, None)
0646         yield ('number', self.__field_number, None)
0647 
0648 
0649 
0650 
0651 class speeddials(BaseProtogenClass):
0652     __fields=['speeddials']
0653 
0654     def __init__(self, *args, **kwargs):
0655         dict={}
0656         # What was supplied to this function
0657         dict.update(kwargs)
0658         # Parent constructor
0659         super(speeddials,self).__init__(**dict)
0660         if self.__class__ is speeddials:
0661             self._update(args,dict)
0662 
0663 
0664     def getfields(self):
0665         return self.__fields
0666 
0667 
0668     def _update(self, args, kwargs):
0669         super(speeddials,self)._update(args,kwargs)
0670         keys=kwargs.keys()
0671         for key in keys:
0672             if key in self.__fields:
0673                 setattr(self, key, kwargs[key])
0674                 del kwargs[key]
0675         # Were any unrecognized kwargs passed in?
0676         if __debug__:
0677             self._complainaboutunusedargs(speeddials,kwargs)
0678         if len(args):
0679             dict2={'length': NUMSPEEDDIALS, 'elementclass': speeddial}
0680             dict2.update(kwargs)
0681             kwargs=dict2
0682             self.__field_speeddials=LIST(*args,**dict2)
0683         # Make all P fields that haven't already been constructed
0684 
0685 
0686     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0687         'Writes this packet to the supplied buffer'
0688         self._bufferstartoffset=buf.getcurrentoffset()
0689         try: self.__field_speeddials
0690         except:
0691             self.__field_speeddials=LIST(**{'length': NUMSPEEDDIALS, 'elementclass': speeddial})
0692         self.__field_speeddials.writetobuffer(buf)
0693         self._bufferendoffset=buf.getcurrentoffset()
0694         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0695 
0696 
0697     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0698         'Reads this packet from the supplied buffer'
0699         self._bufferstartoffset=buf.getcurrentoffset()
0700         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0701         self.__field_speeddials=LIST(**{'length': NUMSPEEDDIALS, 'elementclass': speeddial})
0702         self.__field_speeddials.readfrombuffer(buf)
0703         self._bufferendoffset=buf.getcurrentoffset()
0704 
0705 
0706     def __getfield_speeddials(self):
0707         try: self.__field_speeddials
0708         except:
0709             self.__field_speeddials=LIST(**{'length': NUMSPEEDDIALS, 'elementclass': speeddial})
0710         return self.__field_speeddials.getvalue()
0711 
0712     def __setfield_speeddials(self, value):
0713         if isinstance(value,LIST):
0714             self.__field_speeddials=value
0715         else:
0716             self.__field_speeddials=LIST(value,**{'length': NUMSPEEDDIALS, 'elementclass': speeddial})
0717 
0718     def __delfield_speeddials(self): del self.__field_speeddials
0719 
0720     speeddials=property(__getfield_speeddials, __setfield_speeddials, __delfield_speeddials, None)
0721 
0722     def iscontainer(self):
0723         return True
0724 
0725     def containerelements(self):
0726         yield ('speeddials', self.__field_speeddials, None)
0727 
0728 
0729 
0730 
0731 class pbgroup(BaseProtogenClass):
0732     __fields=['name', 'ringtone']
0733 
0734     def __init__(self, *args, **kwargs):
0735         dict={}
0736         # What was supplied to this function
0737         dict.update(kwargs)
0738         # Parent constructor
0739         super(pbgroup,self).__init__(**dict)
0740         if self.__class__ is pbgroup:
0741             self._update(args,dict)
0742 
0743 
0744     def getfields(self):
0745         return self.__fields
0746 
0747 
0748     def _update(self, args, kwargs):
0749         super(pbgroup,self)._update(args,kwargs)
0750         keys=kwargs.keys()
0751         for key in keys:
0752             if key in self.__fields:
0753                 setattr(self, key, kwargs[key])
0754                 del kwargs[key]
0755         # Were any unrecognized kwargs passed in?
0756         if __debug__:
0757             self._complainaboutunusedargs(pbgroup,kwargs)
0758         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0759         # Make all P fields that haven't already been constructed
0760 
0761 
0762     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0763         'Writes this packet to the supplied buffer'
0764         self._bufferstartoffset=buf.getcurrentoffset()
0765         self.__field_name.writetobuffer(buf)
0766         try: self.__field_ringtone
0767         except:
0768             self.__field_ringtone=UINT(**{'sizeinbytes': 2,  'default': 0xffff })
0769         self.__field_ringtone.writetobuffer(buf)
0770         self._bufferendoffset=buf.getcurrentoffset()
0771         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0772 
0773 
0774     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0775         'Reads this packet from the supplied buffer'
0776         self._bufferstartoffset=buf.getcurrentoffset()
0777         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0778         self.__field_name=USTRING(**{'sizeinbytes': 23, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False })
0779         self.__field_name.readfrombuffer(buf)
0780         self.__field_ringtone=UINT(**{'sizeinbytes': 2,  'default': 0xffff })
0781         self.__field_ringtone.readfrombuffer(buf)
0782         self._bufferendoffset=buf.getcurrentoffset()
0783 
0784 
0785     def __getfield_name(self):
0786         return self.__field_name.getvalue()
0787 
0788     def __setfield_name(self, value):
0789         if isinstance(value,USTRING):
0790             self.__field_name=value
0791         else:
0792             self.__field_name=USTRING(value,**{'sizeinbytes': 23, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False })
0793 
0794     def __delfield_name(self): del self.__field_name
0795 
0796     name=property(__getfield_name, __setfield_name, __delfield_name, None)
0797 
0798     def __getfield_ringtone(self):
0799         try: self.__field_ringtone
0800         except:
0801             self.__field_ringtone=UINT(**{'sizeinbytes': 2,  'default': 0xffff })
0802         return self.__field_ringtone.getvalue()
0803 
0804     def __setfield_ringtone(self, value):
0805         if isinstance(value,UINT):
0806             self.__field_ringtone=value
0807         else:
0808             self.__field_ringtone=UINT(value,**{'sizeinbytes': 2,  'default': 0xffff })
0809 
0810     def __delfield_ringtone(self): del self.__field_ringtone
0811 
0812     ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None)
0813 
0814     def iscontainer(self):
0815         return True
0816 
0817     def containerelements(self):
0818         yield ('name', self.__field_name, None)
0819         yield ('ringtone', self.__field_ringtone, None)
0820 
0821 
0822 
0823 
0824 class pbgroups(BaseProtogenClass):
0825     "Phonebook groups"
0826     __fields=['groups']
0827 
0828     def __init__(self, *args, **kwargs):
0829         dict={}
0830         # What was supplied to this function
0831         dict.update(kwargs)
0832         # Parent constructor
0833         super(pbgroups,self).__init__(**dict)
0834         if self.__class__ is pbgroups:
0835             self._update(args,dict)
0836 
0837 
0838     def getfields(self):
0839         return self.__fields
0840 
0841 
0842     def _update(self, args, kwargs):
0843         super(pbgroups,self)._update(args,kwargs)
0844         keys=kwargs.keys()
0845         for key in keys:
0846             if key in self.__fields:
0847                 setattr(self, key, kwargs[key])
0848                 del kwargs[key]
0849         # Were any unrecognized kwargs passed in?
0850         if __debug__:
0851             self._complainaboutunusedargs(pbgroups,kwargs)
0852         if len(args):
0853             dict2={'elementclass': pbgroup}
0854             dict2.update(kwargs)
0855             kwargs=dict2
0856             self.__field_groups=LIST(*args,**dict2)
0857         # Make all P fields that haven't already been constructed
0858 
0859 
0860     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0861         'Writes this packet to the supplied buffer'
0862         self._bufferstartoffset=buf.getcurrentoffset()
0863         try: self.__field_groups
0864         except:
0865             self.__field_groups=LIST(**{'elementclass': pbgroup})
0866         self.__field_groups.writetobuffer(buf)
0867         self._bufferendoffset=buf.getcurrentoffset()
0868         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0869 
0870 
0871     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0872         'Reads this packet from the supplied buffer'
0873         self._bufferstartoffset=buf.getcurrentoffset()
0874         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0875         self.__field_groups=LIST(**{'elementclass': pbgroup})
0876         self.__field_groups.readfrombuffer(buf)
0877         self._bufferendoffset=buf.getcurrentoffset()
0878 
0879 
0880     def __getfield_groups(self):
0881         try: self.__field_groups
0882         except:
0883             self.__field_groups=LIST(**{'elementclass': pbgroup})
0884         return self.__field_groups.getvalue()
0885 
0886     def __setfield_groups(self, value):
0887         if isinstance(value,LIST):
0888             self.__field_groups=value
0889         else:
0890             self.__field_groups=LIST(value,**{'elementclass': pbgroup})
0891 
0892     def __delfield_groups(self): del self.__field_groups
0893 
0894     groups=property(__getfield_groups, __setfield_groups, __delfield_groups, None)
0895 
0896     def iscontainer(self):
0897         return True
0898 
0899     def containerelements(self):
0900         yield ('groups', self.__field_groups, None)
0901 
0902 
0903 
0904 
0905 class pbinforequest(BaseProtogenClass):
0906     "Random information about the phone"
0907     __fields=['header', 'pad']
0908 
0909     def __init__(self, *args, **kwargs):
0910         dict={}
0911         # What was supplied to this function
0912         dict.update(kwargs)
0913         # Parent constructor
0914         super(pbinforequest,self).__init__(**dict)
0915         if self.__class__ is pbinforequest:
0916             self._update(args,dict)
0917 
0918 
0919     def getfields(self):
0920         return self.__fields
0921 
0922 
0923     def _update(self, args, kwargs):
0924         super(pbinforequest,self)._update(args,kwargs)
0925         keys=kwargs.keys()
0926         for key in keys:
0927             if key in self.__fields:
0928                 setattr(self, key, kwargs[key])
0929                 del kwargs[key]
0930         # Were any unrecognized kwargs passed in?
0931         if __debug__:
0932             self._complainaboutunusedargs(pbinforequest,kwargs)
0933         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0934         # Make all P fields that haven't already been constructed
0935 
0936 
0937     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0938         'Writes this packet to the supplied buffer'
0939         self._bufferstartoffset=buf.getcurrentoffset()
0940         try: self.__field_header
0941         except:
0942             self.__field_header=pbheader(**{'command': 0x15, 'flag': 0x01})
0943         self.__field_header.writetobuffer(buf)
0944         try: self.__field_pad
0945         except:
0946             self.__field_pad=UNKNOWN(**{'sizeinbytes': 6})
0947         self.__field_pad.writetobuffer(buf)
0948         self._bufferendoffset=buf.getcurrentoffset()
0949         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0950 
0951 
0952     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0953         'Reads this packet from the supplied buffer'
0954         self._bufferstartoffset=buf.getcurrentoffset()
0955         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0956         self.__field_header=pbheader(**{'command': 0x15, 'flag': 0x01})
0957         self.__field_header.readfrombuffer(buf)
0958         self.__field_pad=UNKNOWN(**{'sizeinbytes': 6})
0959         self.__field_pad.readfrombuffer(buf)
0960         self._bufferendoffset=buf.getcurrentoffset()
0961 
0962 
0963     def __getfield_header(self):
0964         try: self.__field_header
0965         except:
0966             self.__field_header=pbheader(**{'command': 0x15, 'flag': 0x01})
0967         return self.__field_header.getvalue()
0968 
0969     def __setfield_header(self, value):
0970         if isinstance(value,pbheader):
0971             self.__field_header=value
0972         else:
0973             self.__field_header=pbheader(value,**{'command': 0x15, 'flag': 0x01})
0974 
0975     def __delfield_header(self): del self.__field_header
0976 
0977     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0978 
0979     def __getfield_pad(self):
0980         try: self.__field_pad
0981         except:
0982             self.__field_pad=UNKNOWN(**{'sizeinbytes': 6})
0983         return self.__field_pad.getvalue()
0984 
0985     def __setfield_pad(self, value):
0986         if isinstance(value,UNKNOWN):
0987             self.__field_pad=value
0988         else:
0989             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 6})
0990 
0991     def __delfield_pad(self): del self.__field_pad
0992 
0993     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
0994 
0995     def iscontainer(self):
0996         return True
0997 
0998     def containerelements(self):
0999         yield ('header', self.__field_header, None)
1000         yield ('pad', self.__field_pad, None)
1001 
1002 
1003 
1004 
1005 class pbinforesponse(BaseProtogenClass):
1006     __fields=['header', 'dunno1', 'firstentry', 'numentries', 'dunno2']
1007 
1008     def __init__(self, *args, **kwargs):
1009         dict={}
1010         # What was supplied to this function
1011         dict.update(kwargs)
1012         # Parent constructor
1013         super(pbinforesponse,self).__init__(**dict)
1014         if self.__class__ is pbinforesponse:
1015             self._update(args,dict)
1016 
1017 
1018     def getfields(self):
1019         return self.__fields
1020 
1021 
1022     def _update(self, args, kwargs):
1023         super(pbinforesponse,self)._update(args,kwargs)
1024         keys=kwargs.keys()
1025         for key in keys:
1026             if key in self.__fields:
1027                 setattr(self, key, kwargs[key])
1028                 del kwargs[key]
1029         # Were any unrecognized kwargs passed in?
1030         if __debug__:
1031             self._complainaboutunusedargs(pbinforesponse,kwargs)
1032         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1033         # Make all P fields that haven't already been constructed
1034 
1035 
1036     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1037         'Writes this packet to the supplied buffer'
1038         self._bufferstartoffset=buf.getcurrentoffset()
1039         self.__field_header.writetobuffer(buf)
1040         self.__field_dunno1.writetobuffer(buf)
1041         self.__field_firstentry.writetobuffer(buf)
1042         self.__field_numentries.writetobuffer(buf)
1043         self.__field_dunno2.writetobuffer(buf)
1044         self._bufferendoffset=buf.getcurrentoffset()
1045         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1046 
1047 
1048     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1049         'Reads this packet from the supplied buffer'
1050         self._bufferstartoffset=buf.getcurrentoffset()
1051         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1052         self.__field_header=pbheader()
1053         self.__field_header.readfrombuffer(buf)
1054         self.__field_dunno1=UNKNOWN(**{'sizeinbytes': 10})
1055         self.__field_dunno1.readfrombuffer(buf)
1056         self.__field_firstentry=UINT(**{'sizeinbytes': 4})
1057         self.__field_firstentry.readfrombuffer(buf)
1058         self.__field_numentries=UINT(**{'sizeinbytes': 2})
1059         self.__field_numentries.readfrombuffer(buf)
1060         self.__field_dunno2=UNKNOWN()
1061         self.__field_dunno2.readfrombuffer(buf)
1062         self._bufferendoffset=buf.getcurrentoffset()
1063 
1064 
1065     def __getfield_header(self):
1066         return self.__field_header.getvalue()
1067 
1068     def __setfield_header(self, value):
1069         if isinstance(value,pbheader):
1070             self.__field_header=value
1071         else:
1072             self.__field_header=pbheader(value,)
1073 
1074     def __delfield_header(self): del self.__field_header
1075 
1076     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1077 
1078     def __getfield_dunno1(self):
1079         return self.__field_dunno1.getvalue()
1080 
1081     def __setfield_dunno1(self, value):
1082         if isinstance(value,UNKNOWN):
1083             self.__field_dunno1=value
1084         else:
1085             self.__field_dunno1=UNKNOWN(value,**{'sizeinbytes': 10})
1086 
1087     def __delfield_dunno1(self): del self.__field_dunno1
1088 
1089     dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None)
1090 
1091     def __getfield_firstentry(self):
1092         return self.__field_firstentry.getvalue()
1093 
1094     def __setfield_firstentry(self, value):
1095         if isinstance(value,UINT):
1096             self.__field_firstentry=value
1097         else:
1098             self.__field_firstentry=UINT(value,**{'sizeinbytes': 4})
1099 
1100     def __delfield_firstentry(self): del self.__field_firstentry
1101 
1102     firstentry=property(__getfield_firstentry, __setfield_firstentry, __delfield_firstentry, None)
1103 
1104     def __getfield_numentries(self):
1105         return self.__field_numentries.getvalue()
1106 
1107     def __setfield_numentries(self, value):
1108         if isinstance(value,UINT):
1109             self.__field_numentries=value
1110         else:
1111             self.__field_numentries=UINT(value,**{'sizeinbytes': 2})
1112 
1113     def __delfield_numentries(self): del self.__field_numentries
1114 
1115     numentries=property(__getfield_numentries, __setfield_numentries, __delfield_numentries, None)
1116 
1117     def __getfield_dunno2(self):
1118         return self.__field_dunno2.getvalue()
1119 
1120     def __setfield_dunno2(self, value):
1121         if isinstance(value,UNKNOWN):
1122             self.__field_dunno2=value
1123         else:
1124             self.__field_dunno2=UNKNOWN(value,)
1125 
1126     def __delfield_dunno2(self): del self.__field_dunno2
1127 
1128     dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None)
1129 
1130     def iscontainer(self):
1131         return True
1132 
1133     def containerelements(self):
1134         yield ('header', self.__field_header, None)
1135         yield ('dunno1', self.__field_dunno1, None)
1136         yield ('firstentry', self.__field_firstentry, None)
1137         yield ('numentries', self.__field_numentries, None)
1138         yield ('dunno2', self.__field_dunno2, None)
1139 
1140 
1141 
1142 
1143 class pbfileentry(BaseProtogenClass):
1144     __fields=['serial1', 'entrynumber', 'data1', 'ringtone', 'group', 'wallpaper', 'data2', 'unknown']
1145 
1146     def __init__(self, *args, **kwargs):
1147         dict={}
1148         # What was supplied to this function
1149         dict.update(kwargs)
1150         # Parent constructor
1151         super(pbfileentry,self).__init__(**dict)
1152         if self.__class__ is pbfileentry:
1153             self._update(args,dict)
1154 
1155 
1156     def getfields(self):
1157         return self.__fields
1158 
1159 
1160     def _update(self, args, kwargs):
1161         super(pbfileentry,self)._update(args,kwargs)
1162         keys=kwargs.keys()
1163         for key in keys:
1164             if key in self.__fields:
1165                 setattr(self, key, kwargs[key])
1166                 del kwargs[key]
1167         # Were any unrecognized kwargs passed in?
1168         if __debug__:
1169             self._complainaboutunusedargs(pbfileentry,kwargs)
1170         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1171         # Make all P fields that haven't already been constructed
1172 
1173 
1174     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1175         'Writes this packet to the supplied buffer'
1176         self._bufferstartoffset=buf.getcurrentoffset()
1177         self.__field_serial1.writetobuffer(buf)
1178         self.__field_entrynumber.writetobuffer(buf)
1179         self.__field_data1.writetobuffer(buf)
1180         self.__field_ringtone.writetobuffer(buf)
1181         self.__field_group.writetobuffer(buf)
1182         self.__field_wallpaper.writetobuffer(buf)
1183         self.__field_data2.writetobuffer(buf)
1184         self.__field_unknown.writetobuffer(buf)
1185         self._bufferendoffset=buf.getcurrentoffset()
1186         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1187 
1188 
1189     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1190         'Reads this packet from the supplied buffer'
1191         self._bufferstartoffset=buf.getcurrentoffset()
1192         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1193         self.__field_serial1=UINT(**{'sizeinbytes': 4})
1194         self.__field_serial1.readfrombuffer(buf)
1195         self.__field_entrynumber=UINT(**{'sizeinbytes': 2})
1196         self.__field_entrynumber.readfrombuffer(buf)
1197         self.__field_data1=DATA(**{'sizeinbytes': 172})
1198         self.__field_data1.readfrombuffer(buf)
1199         self.__field_ringtone=UINT(**{'sizeinbytes': 2})
1200         self.__field_ringtone.readfrombuffer(buf)
1201         self.__field_group=UINT(**{'sizeinbytes': 2})
1202         self.__field_group.readfrombuffer(buf)
1203         self.__field_wallpaper=UINT(**{'sizeinbytes': 2})
1204         self.__field_wallpaper.readfrombuffer(buf)
1205         self.__field_data2=DATA(**{'sizeinbytes': 256})
1206         self.__field_data2.readfrombuffer(buf)
1207         self.__field_unknown=UNKNOWN()
1208         self.__field_unknown.readfrombuffer(buf)
1209         self._bufferendoffset=buf.getcurrentoffset()
1210 
1211 
1212     def __getfield_serial1(self):
1213         return self.__field_serial1.getvalue()
1214 
1215     def __setfield_serial1(self, value):
1216         if isinstance(value,UINT):
1217             self.__field_serial1=value
1218         else:
1219             self.__field_serial1=UINT(value,**{'sizeinbytes': 4})
1220 
1221     def __delfield_serial1(self): del self.__field_serial1
1222 
1223     serial1=property(__getfield_serial1, __setfield_serial1, __delfield_serial1, None)
1224 
1225     def __getfield_entrynumber(self):
1226         return self.__field_entrynumber.getvalue()
1227 
1228     def __setfield_entrynumber(self, value):
1229         if isinstance(value,UINT):
1230             self.__field_entrynumber=value
1231         else:
1232             self.__field_entrynumber=UINT(value,**{'sizeinbytes': 2})
1233 
1234     def __delfield_entrynumber(self): del self.__field_entrynumber
1235 
1236     entrynumber=property(__getfield_entrynumber, __setfield_entrynumber, __delfield_entrynumber, None)
1237 
1238     def __getfield_data1(self):
1239         return self.__field_data1.getvalue()
1240 
1241     def __setfield_data1(self, value):
1242         if isinstance(value,DATA):
1243             self.__field_data1=value
1244         else:
1245             self.__field_data1=DATA(value,**{'sizeinbytes': 172})
1246 
1247     def __delfield_data1(self): del self.__field_data1
1248 
1249     data1=property(__getfield_data1, __setfield_data1, __delfield_data1, None)
1250 
1251     def __getfield_ringtone(self):
1252         return self.__field_ringtone.getvalue()
1253 
1254     def __setfield_ringtone(self, value):
1255         if isinstance(value,UINT):
1256             self.__field_ringtone=value
1257         else:
1258             self.__field_ringtone=UINT(value,**{'sizeinbytes': 2})
1259 
1260     def __delfield_ringtone(self): del self.__field_ringtone
1261 
1262     ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None)
1263 
1264     def __getfield_group(self):
1265         return self.__field_group.getvalue()
1266 
1267     def __setfield_group(self, value):
1268         if isinstance(value,UINT):
1269             self.__field_group=value
1270         else:
1271             self.__field_group=UINT(value,**{'sizeinbytes': 2})
1272 
1273     def __delfield_group(self): del self.__field_group
1274 
1275     group=property(__getfield_group, __setfield_group, __delfield_group, None)
1276 
1277     def __getfield_wallpaper(self):
1278         return self.__field_wallpaper.getvalue()
1279 
1280     def __setfield_wallpaper(self, value):
1281         if isinstance(value,UINT):
1282             self.__field_wallpaper=value
1283         else:
1284             self.__field_wallpaper=UINT(value,**{'sizeinbytes': 2})
1285 
1286     def __delfield_wallpaper(self): del self.__field_wallpaper
1287 
1288     wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None)
1289 
1290     def __getfield_data2(self):
1291         return self.__field_data2.getvalue()
1292 
1293     def __setfield_data2(self, value):
1294         if isinstance(value,DATA):
1295             self.__field_data2=value
1296         else:
1297             self.__field_data2=DATA(value,**{'sizeinbytes': 256})
1298 
1299     def __delfield_data2(self): del self.__field_data2
1300 
1301     data2=property(__getfield_data2, __setfield_data2, __delfield_data2, None)
1302 
1303     def __getfield_unknown(self):
1304         return self.__field_unknown.getvalue()
1305 
1306     def __setfield_unknown(self, value):
1307         if isinstance(value,UNKNOWN):
1308             self.__field_unknown=value
1309         else:
1310             self.__field_unknown=UNKNOWN(value,)
1311 
1312     def __delfield_unknown(self): del self.__field_unknown
1313 
1314     unknown=property(__getfield_unknown, __setfield_unknown, __delfield_unknown, None)
1315 
1316     def iscontainer(self):
1317         return True
1318 
1319     def containerelements(self):
1320         yield ('serial1', self.__field_serial1, None)
1321         yield ('entrynumber', self.__field_entrynumber, None)
1322         yield ('data1', self.__field_data1, None)
1323         yield ('ringtone', self.__field_ringtone, None)
1324         yield ('group', self.__field_group, None)
1325         yield ('wallpaper', self.__field_wallpaper, None)
1326         yield ('data2', self.__field_data2, None)
1327         yield ('unknown', self.__field_unknown, None)
1328 
1329 
1330 
1331 
1332 class pbfile(BaseProtogenClass):
1333     __fields=['items']
1334 
1335     def __init__(self, *args, **kwargs):
1336         dict={}
1337         # What was supplied to this function
1338         dict.update(kwargs)
1339         # Parent constructor
1340         super(pbfile,self).__init__(**dict)
1341         if self.__class__ is pbfile:
1342             self._update(args,dict)
1343 
1344 
1345     def getfields(self):
1346         return self.__fields
1347 
1348 
1349     def _update(self, args, kwargs):
1350         super(pbfile,self)._update(args,kwargs)
1351         keys=kwargs.keys()
1352         for key in keys:
1353             if key in self.__fields:
1354                 setattr(self, key, kwargs[key])
1355                 del kwargs[key]
1356         # Were any unrecognized kwargs passed in?
1357         if __debug__:
1358             self._complainaboutunusedargs(pbfile,kwargs)
1359         if len(args):
1360             dict2={ 'elementclass': pbfileentry }
1361             dict2.update(kwargs)
1362             kwargs=dict2
1363             self.__field_items=LIST(*args,**dict2)
1364         # Make all P fields that haven't already been constructed
1365 
1366 
1367     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1368         'Writes this packet to the supplied buffer'
1369         self._bufferstartoffset=buf.getcurrentoffset()
1370         self.__field_items.writetobuffer(buf)
1371         self._bufferendoffset=buf.getcurrentoffset()
1372         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1373 
1374 
1375     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1376         'Reads this packet from the supplied buffer'
1377         self._bufferstartoffset=buf.getcurrentoffset()
1378         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1379         self.__field_items=LIST(**{ 'elementclass': pbfileentry })
1380         self.__field_items.readfrombuffer(buf)
1381         self._bufferendoffset=buf.getcurrentoffset()
1382 
1383 
1384     def __getfield_items(self):
1385         return self.__field_items.getvalue()
1386 
1387     def __setfield_items(self, value):
1388         if isinstance(value,LIST):
1389             self.__field_items=value
1390         else:
1391             self.__field_items=LIST(value,**{ 'elementclass': pbfileentry })
1392 
1393     def __delfield_items(self): del self.__field_items
1394 
1395     items=property(__getfield_items, __setfield_items, __delfield_items, None)
1396 
1397     def iscontainer(self):
1398         return True
1399 
1400     def containerelements(self):
1401         yield ('items', self.__field_items, None)
1402 
1403 
1404 
1405 
1406 class wallpaper_id(BaseProtogenClass):
1407     __fields=['path']
1408 
1409     def __init__(self, *args, **kwargs):
1410         dict={}
1411         # What was supplied to this function
1412         dict.update(kwargs)
1413         # Parent constructor
1414         super(wallpaper_id,self).__init__(**dict)
1415         if self.__class__ is wallpaper_id:
1416             self._update(args,dict)
1417 
1418 
1419     def getfields(self):
1420         return self.__fields
1421 
1422 
1423     def _update(self, args, kwargs):
1424         super(wallpaper_id,self)._update(args,kwargs)
1425         keys=kwargs.keys()
1426         for key in keys:
1427             if key in self.__fields:
1428                 setattr(self, key, kwargs[key])
1429                 del kwargs[key]
1430         # Were any unrecognized kwargs passed in?
1431         if __debug__:
1432             self._complainaboutunusedargs(wallpaper_id,kwargs)
1433         if len(args):
1434             dict2={'sizeinbytes': 80,  'terminator': None, 'pad': 0xFF, 'default': "" }
1435             dict2.update(kwargs)
1436             kwargs=dict2
1437             self.__field_path=USTRING(*args,**dict2)
1438         # Make all P fields that haven't already been constructed
1439 
1440 
1441     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1442         'Writes this packet to the supplied buffer'
1443         self._bufferstartoffset=buf.getcurrentoffset()
1444         try: self.__field_path
1445         except:
1446             self.__field_path=USTRING(**{'sizeinbytes': 80,  'terminator': None, 'pad': 0xFF, 'default': "" })
1447         self.__field_path.writetobuffer(buf)
1448         self._bufferendoffset=buf.getcurrentoffset()
1449         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1450 
1451 
1452     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1453         'Reads this packet from the supplied buffer'
1454         self._bufferstartoffset=buf.getcurrentoffset()
1455         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1456         self.__field_path=USTRING(**{'sizeinbytes': 80,  'terminator': None, 'pad': 0xFF, 'default': "" })
1457         self.__field_path.readfrombuffer(buf)
1458         self._bufferendoffset=buf.getcurrentoffset()
1459 
1460 
1461     def __getfield_path(self):
1462         try: self.__field_path
1463         except:
1464             self.__field_path=USTRING(**{'sizeinbytes': 80,  'terminator': None, 'pad': 0xFF, 'default': "" })
1465         return self.__field_path.getvalue()
1466 
1467     def __setfield_path(self, value):
1468         if isinstance(value,USTRING):
1469             self.__field_path=value
1470         else:
1471             self.__field_path=USTRING(value,**{'sizeinbytes': 80,  'terminator': None, 'pad': 0xFF, 'default': "" })
1472 
1473     def __delfield_path(self): del self.__field_path
1474 
1475     path=property(__getfield_path, __setfield_path, __delfield_path, None)
1476 
1477     def iscontainer(self):
1478         return True
1479 
1480     def containerelements(self):
1481         yield ('path', self.__field_path, None)
1482 
1483 
1484 
1485 
1486 class wallpaper_id_file(BaseProtogenClass):
1487     __fields=['items']
1488 
1489     def __init__(self, *args, **kwargs):
1490         dict={}
1491         # What was supplied to this function
1492         dict.update(kwargs)
1493         # Parent constructor
1494         super(wallpaper_id_file,self).__init__(**dict)
1495         if self.__class__ is wallpaper_id_file:
1496             self._update(args,dict)
1497 
1498 
1499     def getfields(self):
1500         return self.__fields
1501 
1502 
1503     def _update(self, args, kwargs):
1504         super(wallpaper_id_file,self)._update(args,kwargs)
1505         keys=kwargs.keys()
1506         for key in keys:
1507             if key in self.__fields:
1508                 setattr(self, key, kwargs[key])
1509                 del kwargs[key]
1510         # Were any unrecognized kwargs passed in?
1511         if __debug__:
1512             self._complainaboutunusedargs(wallpaper_id_file,kwargs)
1513         if len(args):
1514             dict2={ 'length': NUMPHONEBOOKENTRIES,             'elementclass': wallpaper_id,             'createdefault': True }
1515             dict2.update(kwargs)
1516             kwargs=dict2
1517             self.__field_items=LIST(*args,**dict2)
1518         # Make all P fields that haven't already been constructed
1519 
1520 
1521     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1522         'Writes this packet to the supplied buffer'
1523         self._bufferstartoffset=buf.getcurrentoffset()
1524         try: self.__field_items
1525         except:
1526             self.__field_items=LIST(**{ 'length': NUMPHONEBOOKENTRIES,             'elementclass': wallpaper_id,             'createdefault': True })
1527         self.__field_items.writetobuffer(buf)
1528         self._bufferendoffset=buf.getcurrentoffset()
1529         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1530 
1531 
1532     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1533         'Reads this packet from the supplied buffer'
1534         self._bufferstartoffset=buf.getcurrentoffset()
1535         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1536         self.__field_items=LIST(**{ 'length': NUMPHONEBOOKENTRIES,             'elementclass': wallpaper_id,             'createdefault': True })
1537         self.__field_items.readfrombuffer(buf)
1538         self._bufferendoffset=buf.getcurrentoffset()
1539 
1540 
1541     def __getfield_items(self):
1542         try: self.__field_items
1543         except:
1544             self.__field_items=LIST(**{ 'length': NUMPHONEBOOKENTRIES,             'elementclass': wallpaper_id,             'createdefault': True })
1545         return self.__field_items.getvalue()
1546 
1547     def __setfield_items(self, value):
1548         if isinstance(value,LIST):
1549             self.__field_items=value
1550         else:
1551             self.__field_items=LIST(value,**{ 'length': NUMPHONEBOOKENTRIES,             'elementclass': wallpaper_id,             'createdefault': True })
1552 
1553     def __delfield_items(self): del self.__field_items
1554 
1555     items=property(__getfield_items, __setfield_items, __delfield_items, None)
1556 
1557     def iscontainer(self):
1558         return True
1559 
1560     def containerelements(self):
1561         yield ('items', self.__field_items, None)
1562 
1563 
1564 
1565 
1566 class PathIndexEntry(BaseProtogenClass):
1567     __fields=['pathname']
1568 
1569     def __init__(self, *args, **kwargs):
1570         dict={}
1571         # What was supplied to this function
1572         dict.update(kwargs)
1573         # Parent constructor
1574         super(PathIndexEntry,self).__init__(**dict)
1575         if self.__class__ is PathIndexEntry:
1576             self._update(args,dict)
1577 
1578 
1579     def getfields(self):
1580         return self.__fields
1581 
1582 
1583     def _update(self, args, kwargs):
1584         super(PathIndexEntry,self)._update(args,kwargs)
1585         keys=kwargs.keys()
1586         for key in keys:
1587             if key in self.__fields:
1588                 setattr(self, key, kwargs[key])
1589                 del kwargs[key]
1590         # Were any unrecognized kwargs passed in?
1591         if __debug__:
1592             self._complainaboutunusedargs(PathIndexEntry,kwargs)
1593         if len(args):
1594             dict2={'sizeinbytes': 255,  'encoding': PHONE_ENCODING,                  'default': '' }
1595             dict2.update(kwargs)
1596             kwargs=dict2
1597             self.__field_pathname=USTRING(*args,**dict2)
1598         # Make all P fields that haven't already been constructed
1599 
1600 
1601     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1602         'Writes this packet to the supplied buffer'
1603         self._bufferstartoffset=buf.getcurrentoffset()
1604         try: self.__field_pathname
1605         except:
1606             self.__field_pathname=USTRING(**{'sizeinbytes': 255,  'encoding': PHONE_ENCODING,                  'default': '' })
1607         self.__field_pathname.writetobuffer(buf)
1608         self._bufferendoffset=buf.getcurrentoffset()
1609         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1610 
1611 
1612     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1613         'Reads this packet from the supplied buffer'
1614         self._bufferstartoffset=buf.getcurrentoffset()
1615         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1616         self.__field_pathname=USTRING(**{'sizeinbytes': 255,  'encoding': PHONE_ENCODING,                  'default': '' })
1617         self.__field_pathname.readfrombuffer(buf)
1618         self._bufferendoffset=buf.getcurrentoffset()
1619 
1620 
1621     def __getfield_pathname(self):
1622         try: self.__field_pathname
1623         except:
1624             self.__field_pathname=USTRING(**{'sizeinbytes': 255,  'encoding': PHONE_ENCODING,                  'default': '' })
1625         return self.__field_pathname.getvalue()
1626 
1627     def __setfield_pathname(self, value):
1628         if isinstance(value,USTRING):
1629             self.__field_pathname=value
1630         else:
1631             self.__field_pathname=USTRING(value,**{'sizeinbytes': 255,  'encoding': PHONE_ENCODING,                  'default': '' })
1632 
1633     def __delfield_pathname(self): del self.__field_pathname
1634 
1635     pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None)
1636 
1637     def iscontainer(self):
1638         return True
1639 
1640     def containerelements(self):
1641         yield ('pathname', self.__field_pathname, None)
1642 
1643 
1644 
1645 
1646 class PathIndexFile(BaseProtogenClass):
1647     __fields=['items']
1648 
1649     def __init__(self, *args, **kwargs):
1650         dict={}
1651         # What was supplied to this function
1652         dict.update(kwargs)
1653         # Parent constructor
1654         super(PathIndexFile,self).__init__(**dict)
1655         if self.__class__ is PathIndexFile:
1656             self._update(args,dict)
1657 
1658 
1659     def getfields(self):
1660         return self.__fields
1661 
1662 
1663     def _update(self, args, kwargs):
1664         super(PathIndexFile,self)._update(args,kwargs)
1665         keys=kwargs.keys()
1666         for key in keys:
1667             if key in self.__fields:
1668                 setattr(self, key, kwargs[key])
1669                 del kwargs[key]
1670         # Were any unrecognized kwargs passed in?
1671         if __debug__:
1672             self._complainaboutunusedargs(PathIndexFile,kwargs)
1673         if len(args):
1674             dict2={ 'elementclass': PathIndexEntry,             'createdefault': True,             'length': NUMPHONEBOOKENTRIES }
1675             dict2.update(kwargs)
1676             kwargs=dict2
1677             self.__field_items=LIST(*args,**dict2)
1678         # Make all P fields that haven't already been constructed
1679 
1680 
1681     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1682         'Writes this packet to the supplied buffer'
1683         self._bufferstartoffset=buf.getcurrentoffset()
1684         try: self.__field_items
1685         except:
1686             self.__field_items=LIST(**{ 'elementclass': PathIndexEntry,             'createdefault': True,             'length': NUMPHONEBOOKENTRIES })
1687         self.__field_items.writetobuffer(buf)
1688         self._bufferendoffset=buf.getcurrentoffset()
1689         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1690 
1691 
1692     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1693         'Reads this packet from the supplied buffer'
1694         self._bufferstartoffset=buf.getcurrentoffset()
1695         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1696         self.__field_items=LIST(**{ 'elementclass': PathIndexEntry,             'createdefault': True,             'length': NUMPHONEBOOKENTRIES })
1697         self.__field_items.readfrombuffer(buf)
1698         self._bufferendoffset=buf.getcurrentoffset()
1699 
1700 
1701     def __getfield_items(self):
1702         try: self.__field_items
1703         except:
1704             self.__field_items=LIST(**{ 'elementclass': PathIndexEntry,             'createdefault': True,             'length': NUMPHONEBOOKENTRIES })
1705         return self.__field_items.getvalue()
1706 
1707     def __setfield_items(self, value):
1708         if isinstance(value,LIST):
1709             self.__field_items=value
1710         else:
1711             self.__field_items=LIST(value,**{ 'elementclass': PathIndexEntry,             'createdefault': True,             'length': NUMPHONEBOOKENTRIES })
1712 
1713     def __delfield_items(self): del self.__field_items
1714 
1715     items=property(__getfield_items, __setfield_items, __delfield_items, None)
1716 
1717     def iscontainer(self):
1718         return True
1719 
1720     def containerelements(self):
1721         yield ('items', self.__field_items, None)
1722 
1723 
1724 
1725 
1726 class scheduleexception(BaseProtogenClass):
1727     __fields=['pos', 'day', 'month', 'year']
1728 
1729     def __init__(self, *args, **kwargs):
1730         dict={}
1731         # What was supplied to this function
1732         dict.update(kwargs)
1733         # Parent constructor
1734         super(scheduleexception,self).__init__(**dict)
1735         if self.__class__ is scheduleexception:
1736             self._update(args,dict)
1737 
1738 
1739     def getfields(self):
1740         return self.__fields
1741 
1742 
1743     def _update(self, args, kwargs):
1744         super(scheduleexception,self)._update(args,kwargs)
1745         keys=kwargs.keys()
1746         for key in keys:
1747             if key in self.__fields:
1748                 setattr(self, key, kwargs[key])
1749                 del kwargs[key]
1750         # Were any unrecognized kwargs passed in?
1751         if __debug__:
1752             self._complainaboutunusedargs(scheduleexception,kwargs)
1753         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1754         # Make all P fields that haven't already been constructed
1755 
1756 
1757     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1758         'Writes this packet to the supplied buffer'
1759         self._bufferstartoffset=buf.getcurrentoffset()
1760         self.__field_pos.writetobuffer(buf)
1761         self.__field_day.writetobuffer(buf)
1762         self.__field_month.writetobuffer(buf)
1763         self.__field_year.writetobuffer(buf)
1764         self._bufferendoffset=buf.getcurrentoffset()
1765         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1766 
1767 
1768     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1769         'Reads this packet from the supplied buffer'
1770         self._bufferstartoffset=buf.getcurrentoffset()
1771         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1772         self.__field_pos=UINT(**{'sizeinbytes': 4})
1773         self.__field_pos.readfrombuffer(buf)
1774         self.__field_day=UINT(**{'sizeinbytes': 1})
1775         self.__field_day.readfrombuffer(buf)
1776         self.__field_month=UINT(**{'sizeinbytes': 1})
1777         self.__field_month.readfrombuffer(buf)
1778         self.__field_year=UINT(**{'sizeinbytes': 2})
1779         self.__field_year.readfrombuffer(buf)
1780         self._bufferendoffset=buf.getcurrentoffset()
1781 
1782 
1783     def __getfield_pos(self):
1784         return self.__field_pos.getvalue()
1785 
1786     def __setfield_pos(self, value):
1787         if isinstance(value,UINT):
1788             self.__field_pos=value
1789         else:
1790             self.__field_pos=UINT(value,**{'sizeinbytes': 4})
1791 
1792     def __delfield_pos(self): del self.__field_pos
1793 
1794     pos=property(__getfield_pos, __setfield_pos, __delfield_pos, "Refers to event id (position in schedule file) that this suppresses")
1795 
1796     def __getfield_day(self):
1797         return self.__field_day.getvalue()
1798 
1799     def __setfield_day(self, value):
1800         if isinstance(value,UINT):
1801             self.__field_day=value
1802         else:
1803             self.__field_day=UINT(value,**{'sizeinbytes': 1})
1804 
1805     def __delfield_day(self): del self.__field_day
1806 
1807     day=property(__getfield_day, __setfield_day, __delfield_day, None)
1808 
1809     def __getfield_month(self):
1810         return self.__field_month.getvalue()
1811 
1812     def __setfield_month(self, value):
1813         if isinstance(value,UINT):
1814             self.__field_month=value
1815         else:
1816             self.__field_month=UINT(value,**{'sizeinbytes': 1})
1817 
1818     def __delfield_month(self): del self.__field_month
1819 
1820     month=property(__getfield_month, __setfield_month, __delfield_month, None)
1821 
1822     def __getfield_year(self):
1823         return self.__field_year.getvalue()
1824 
1825     def __setfield_year(self, value):
1826         if isinstance(value,UINT):
1827             self.__field_year=value
1828         else:
1829             self.__field_year=UINT(value,**{'sizeinbytes': 2})
1830 
1831     def __delfield_year(self): del self.__field_year
1832 
1833     year=property(__getfield_year, __setfield_year, __delfield_year, None)
1834 
1835     def iscontainer(self):
1836         return True
1837 
1838     def containerelements(self):
1839         yield ('pos', self.__field_pos, "Refers to event id (position in schedule file) that this suppresses")
1840         yield ('day', self.__field_day, None)
1841         yield ('month', self.__field_month, None)
1842         yield ('year', self.__field_year, None)
1843 
1844 
1845 
1846 
1847 class scheduleexceptionfile(BaseProtogenClass):
1848     __fields=['items']
1849 
1850     def __init__(self, *args, **kwargs):
1851         dict={}
1852         # What was supplied to this function
1853         dict.update(kwargs)
1854         # Parent constructor
1855         super(scheduleexceptionfile,self).__init__(**dict)
1856         if self.__class__ is scheduleexceptionfile:
1857             self._update(args,dict)
1858 
1859 
1860     def getfields(self):
1861         return self.__fields
1862 
1863 
1864     def _update(self, args, kwargs):
1865         super(scheduleexceptionfile,self)._update(args,kwargs)
1866         keys=kwargs.keys()
1867         for key in keys:
1868             if key in self.__fields:
1869                 setattr(self, key, kwargs[key])
1870                 del kwargs[key]
1871         # Were any unrecognized kwargs passed in?
1872         if __debug__:
1873             self._complainaboutunusedargs(scheduleexceptionfile,kwargs)
1874         if len(args):
1875             dict2={'elementclass': scheduleexception}
1876             dict2.update(kwargs)
1877             kwargs=dict2
1878             self.__field_items=LIST(*args,**dict2)
1879         # Make all P fields that haven't already been constructed
1880 
1881 
1882     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1883         'Writes this packet to the supplied buffer'
1884         self._bufferstartoffset=buf.getcurrentoffset()
1885         try: self.__field_items
1886         except:
1887             self.__field_items=LIST(**{'elementclass': scheduleexception})
1888         self.__field_items.writetobuffer(buf)
1889         self._bufferendoffset=buf.getcurrentoffset()
1890         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1891 
1892 
1893     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1894         'Reads this packet from the supplied buffer'
1895         self._bufferstartoffset=buf.getcurrentoffset()
1896         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1897         self.__field_items=LIST(**{'elementclass': scheduleexception})
1898         self.__field_items.readfrombuffer(buf)
1899         self._bufferendoffset=buf.getcurrentoffset()
1900 
1901 
1902     def __getfield_items(self):
1903         try: self.__field_items
1904         except:
1905             self.__field_items=LIST(**{'elementclass': scheduleexception})
1906         return self.__field_items.getvalue()
1907 
1908     def __setfield_items(self, value):
1909         if isinstance(value,LIST):
1910             self.__field_items=value
1911         else:
1912             self.__field_items=LIST(value,**{'elementclass': scheduleexception})
1913 
1914     def __delfield_items(self): del self.__field_items
1915 
1916     items=property(__getfield_items, __setfield_items, __delfield_items, None)
1917 
1918     def iscontainer(self):
1919         return True
1920 
1921     def containerelements(self):
1922         yield ('items', self.__field_items, None)
1923 
1924 
1925 
1926 
1927 class scheduleevent(BaseProtogenClass):
1928     __fields=['pos', 'description', 'start', 'end', 'repeat', 'alarmindex_vibrate', 'ringtone', 'alarmminutes', 'alarmhours', 'unknown1', 'unknown2']
1929 
1930     def __init__(self, *args, **kwargs):
1931         dict={}
1932         # What was supplied to this function
1933         dict.update(kwargs)
1934         # Parent constructor
1935         super(scheduleevent,self).__init__(**dict)
1936         if self.__class__ is scheduleevent:
1937             self._update(args,dict)
1938 
1939 
1940     def getfields(self):
1941         return self.__fields
1942 
1943 
1944     def _update(self, args, kwargs):
1945         super(scheduleevent,self)._update(args,kwargs)
1946         keys=kwargs.keys()
1947         for key in keys:
1948             if key in self.__fields:
1949                 setattr(self, key, kwargs[key])
1950                 del kwargs[key]
1951         # Were any unrecognized kwargs passed in?
1952         if __debug__:
1953             self._complainaboutunusedargs(scheduleevent,kwargs)
1954         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1955         # Make all P fields that haven't already been constructed
1956 
1957 
1958     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1959         'Writes this packet to the supplied buffer'
1960         self._bufferstartoffset=buf.getcurrentoffset()
1961         self.__field_pos.writetobuffer(buf)
1962         self.__field_description.writetobuffer(buf)
1963         self.__field_start.writetobuffer(buf)
1964         self.__field_end.writetobuffer(buf)
1965         self.__field_repeat.writetobuffer(buf)
1966         self.__field_alarmindex_vibrate.writetobuffer(buf)
1967         self.__field_ringtone.writetobuffer(buf)
1968         self.__field_alarmminutes.writetobuffer(buf)
1969         self.__field_alarmhours.writetobuffer(buf)
1970         self.__field_unknown1.writetobuffer(buf)
1971         self.__field_unknown2.writetobuffer(buf)
1972         self._bufferendoffset=buf.getcurrentoffset()
1973         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1974 
1975 
1976     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1977         'Reads this packet from the supplied buffer'
1978         self._bufferstartoffset=buf.getcurrentoffset()
1979         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1980         self.__field_pos=UINT(**{'sizeinbytes': 4})
1981         self.__field_pos.readfrombuffer(buf)
1982         self.__field_description=USTRING(**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False })
1983         self.__field_description.readfrombuffer(buf)
1984         self.__field_start=LGCALDATE(**{'sizeinbytes': 4})
1985         self.__field_start.readfrombuffer(buf)
1986         self.__field_end=LGCALDATE(**{'sizeinbytes': 4})
1987         self.__field_end.readfrombuffer(buf)
1988         self.__field_repeat=LGCALREPEAT(**{'sizeinbytes': 4})
1989         self.__field_repeat.readfrombuffer(buf)
1990         self.__field_alarmindex_vibrate=UINT(**{'sizeinbytes': 1})
1991         self.__field_alarmindex_vibrate.readfrombuffer(buf)
1992         self.__field_ringtone=UINT(**{'sizeinbytes': 2})
1993         self.__field_ringtone.readfrombuffer(buf)
1994         self.__field_alarmminutes=UINT(**{'sizeinbytes': 1})
1995         self.__field_alarmminutes.readfrombuffer(buf)
1996         self.__field_alarmhours=UINT(**{'sizeinbytes': 1})
1997         self.__field_alarmhours.readfrombuffer(buf)
1998         self.__field_unknown1=UINT(**{'sizeinbytes': 1})
1999         self.__field_unknown1.readfrombuffer(buf)
2000         self.__field_unknown2=UINT(**{'sizeinbytes': 2})
2001         self.__field_unknown2.readfrombuffer(buf)
2002         self._bufferendoffset=buf.getcurrentoffset()
2003 
2004 
2005     def __getfield_pos(self):
2006         return self.__field_pos.getvalue()
2007 
2008     def __setfield_pos(self, value):
2009         if isinstance(value,UINT):
2010             self.__field_pos=value
2011         else:
2012             self.__field_pos=UINT(value,**{'sizeinbytes': 4})
2013 
2014     def __delfield_pos(self): del self.__field_pos
2015 
2016     pos=property(__getfield_pos, __setfield_pos, __delfield_pos, "position within file, used as an event id")
2017 
2018     def __getfield_description(self):
2019         return self.__field_description.getvalue()
2020 
2021     def __setfield_description(self, value):
2022         if isinstance(value,USTRING):
2023             self.__field_description=value
2024         else:
2025             self.__field_description=USTRING(value,**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False })
2026 
2027     def __delfield_description(self): del self.__field_description
2028 
2029     description=property(__getfield_description, __setfield_description, __delfield_description, None)
2030 
2031     def __getfield_start(self):
2032         return self.__field_start.getvalue()
2033 
2034     def __setfield_start(self, value):
2035         if isinstance(value,LGCALDATE):
2036             self.__field_start=value
2037         else:
2038             self.__field_start=LGCALDATE(value,**{'sizeinbytes': 4})
2039 
2040     def __delfield_start(self): del self.__field_start
2041 
2042     start=property(__getfield_start, __setfield_start, __delfield_start, None)
2043 
2044     def __getfield_end(self):
2045         return self.__field_end.getvalue()
2046 
2047     def __setfield_end(self, value):
2048         if isinstance(value,LGCALDATE):
2049             self.__field_end=value
2050         else:
2051             self.__field_end=LGCALDATE(value,**{'sizeinbytes': 4})
2052 
2053     def __delfield_end(self): del self.__field_end
2054 
2055     end=property(__getfield_end, __setfield_end, __delfield_end, None)
2056 
2057     def __getfield_repeat(self):
2058         return self.__field_repeat.getvalue()
2059 
2060     def __setfield_repeat(self, value):
2061         if isinstance(value,LGCALREPEAT):
2062             self.__field_repeat=value
2063         else:
2064             self.__field_repeat=LGCALREPEAT(value,**{'sizeinbytes': 4})
2065 
2066     def __delfield_repeat(self): del self.__field_repeat
2067 
2068     repeat=property(__getfield_repeat, __setfield_repeat, __delfield_repeat, None)
2069 
2070     def __getfield_alarmindex_vibrate(self):
2071         return self.__field_alarmindex_vibrate.getvalue()
2072 
2073     def __setfield_alarmindex_vibrate(self, value):
2074         if isinstance(value,UINT):
2075             self.__field_alarmindex_vibrate=value
2076         else:
2077             self.__field_alarmindex_vibrate=UINT(value,**{'sizeinbytes': 1})
2078 
2079     def __delfield_alarmindex_vibrate(self): del self.__field_alarmindex_vibrate
2080 
2081     alarmindex_vibrate=property(__getfield_alarmindex_vibrate, __setfield_alarmindex_vibrate, __delfield_alarmindex_vibrate, None)
2082 
2083     def __getfield_ringtone(self):
2084         return self.__field_ringtone.getvalue()
2085 
2086     def __setfield_ringtone(self, value):
2087         if isinstance(value,UINT):
2088             self.__field_ringtone=value
2089         else:
2090             self.__field_ringtone=UINT(value,**{'sizeinbytes': 2})
2091 
2092     def __delfield_ringtone(self): del self.__field_ringtone
2093 
2094     ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None)
2095 
2096     def __getfield_alarmminutes(self):
2097         return self.__field_alarmminutes.getvalue()
2098 
2099     def __setfield_alarmminutes(self, value):
2100         if isinstance(value,UINT):
2101             self.__field_alarmminutes=value
2102         else:
2103             self.__field_alarmminutes=UINT(value,**{'sizeinbytes': 1})
2104 
2105     def __delfield_alarmminutes(self): del self.__field_alarmminutes
2106 
2107     alarmminutes=property(__getfield_alarmminutes, __setfield_alarmminutes, __delfield_alarmminutes, "a value of 0xFF indicates not set")
2108 
2109     def __getfield_alarmhours(self):
2110         return self.__field_alarmhours.getvalue()
2111 
2112     def __setfield_alarmhours(self, value):
2113         if isinstance(value,UINT):
2114             self.__field_alarmhours=value
2115         else:
2116             self.__field_alarmhours=UINT(value,**{'sizeinbytes': 1})
2117 
2118     def __delfield_alarmhours(self): del self.__field_alarmhours
2119 
2120     alarmhours=property(__getfield_alarmhours, __setfield_alarmhours, __delfield_alarmhours, "a value of 0xFF indicates not set")
2121 
2122     def __getfield_unknown1(self):
2123         return self.__field_unknown1.getvalue()
2124 
2125     def __setfield_unknown1(self, value):
2126         if isinstance(value,UINT):
2127             self.__field_unknown1=value
2128         else:
2129             self.__field_unknown1=UINT(value,**{'sizeinbytes': 1})
2130 
2131     def __delfield_unknown1(self): del self.__field_unknown1
2132 
2133     unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None)
2134 
2135     def __getfield_unknown2(self):
2136         return self.__field_unknown2.getvalue()
2137 
2138     def __setfield_unknown2(self, value):
2139         if isinstance(value,UINT):
2140             self.__field_unknown2=value
2141         else:
2142             self.__field_unknown2=UINT(value,**{'sizeinbytes': 2})
2143 
2144     def __delfield_unknown2(self): del self.__field_unknown2
2145 
2146     unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None)
2147 
2148     def iscontainer(self):
2149         return True
2150 
2151     def containerelements(self):
2152         yield ('pos', self.__field_pos, "position within file, used as an event id")
2153         yield ('description', self.__field_description, None)
2154         yield ('start', self.__field_start, None)
2155         yield ('end', self.__field_end, None)
2156         yield ('repeat', self.__field_repeat, None)
2157         yield ('alarmindex_vibrate', self.__field_alarmindex_vibrate, None)
2158         yield ('ringtone', self.__field_ringtone, None)
2159         yield ('alarmminutes', self.__field_alarmminutes, "a value of 0xFF indicates not set")
2160         yield ('alarmhours', self.__field_alarmhours, "a value of 0xFF indicates not set")
2161         yield ('unknown1', self.__field_unknown1, None)
2162         yield ('unknown2', self.__field_unknown2, None)
2163 
2164 
2165 
2166 
2167 class schedulefile(BaseProtogenClass):
2168     __fields=['numactiveitems', 'events']
2169 
2170     def __init__(self, *args, **kwargs):
2171         dict={}
2172         # What was supplied to this function
2173         dict.update(kwargs)
2174         # Parent constructor
2175         super(schedulefile,self).__init__(**dict)
2176         if self.__class__ is schedulefile:
2177             self._update(args,dict)
2178 
2179 
2180     def getfields(self):
2181         return self.__fields
2182 
2183 
2184     def _update(self, args, kwargs):
2185         super(schedulefile,self)._update(args,kwargs)
2186         keys=kwargs.keys()
2187         for key in keys:
2188             if key in self.__fields:
2189                 setattr(self, key, kwargs[key])
2190                 del kwargs[key]
2191         # Were any unrecognized kwargs passed in?
2192         if __debug__:
2193             self._complainaboutunusedargs(schedulefile,kwargs)
2194         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2195         # Make all P fields that haven't already been constructed
2196 
2197 
2198     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2199         'Writes this packet to the supplied buffer'
2200         self._bufferstartoffset=buf.getcurrentoffset()
2201         self.__field_numactiveitems.writetobuffer(buf)
2202         try: self.__field_events
2203         except:
2204             self.__field_events=LIST(**{'elementclass': scheduleevent})
2205         self.__field_events.writetobuffer(buf)
2206         self._bufferendoffset=buf.getcurrentoffset()
2207         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2208 
2209 
2210     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2211         'Reads this packet from the supplied buffer'
2212         self._bufferstartoffset=buf.getcurrentoffset()
2213         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2214         self.__field_numactiveitems=UINT(**{'sizeinbytes': 2})
2215         self.__field_numactiveitems.readfrombuffer(buf)
2216         self.__field_events=LIST(**{'elementclass': scheduleevent})
2217         self.__field_events.readfrombuffer(buf)
2218         self._bufferendoffset=buf.getcurrentoffset()
2219 
2220 
2221     def __getfield_numactiveitems(self):
2222         return self.__field_numactiveitems.getvalue()
2223 
2224     def __setfield_numactiveitems(self, value):
2225         if isinstance(value,UINT):
2226             self.__field_numactiveitems=value
2227         else:
2228             self.__field_numactiveitems=UINT(value,**{'sizeinbytes': 2})
2229 
2230     def __delfield_numactiveitems(self): del self.__field_numactiveitems
2231 
2232     numactiveitems=property(__getfield_numactiveitems, __setfield_numactiveitems, __delfield_numactiveitems, None)
2233 
2234     def __getfield_events(self):
2235         try: self.__field_events
2236         except:
2237             self.__field_events=LIST(**{'elementclass': scheduleevent})
2238         return self.__field_events.getvalue()
2239 
2240     def __setfield_events(self, value):
2241         if isinstance(value,LIST):
2242             self.__field_events=value
2243         else:
2244             self.__field_events=LIST(value,**{'elementclass': scheduleevent})
2245 
2246     def __delfield_events(self): del self.__field_events
2247 
2248     events=property(__getfield_events, __setfield_events, __delfield_events, None)
2249 
2250     def iscontainer(self):
2251         return True
2252 
2253     def containerelements(self):
2254         yield ('numactiveitems', self.__field_numactiveitems, None)
2255         yield ('events', self.__field_events, None)
2256 
2257 
2258 
2259 
2260 class ULReq(BaseProtogenClass):
2261     ""
2262     __fields=['cmd', 'unlock_code', 'unlock_key', 'zero']
2263 
2264     def __init__(self, *args, **kwargs):
2265         dict={}
2266         # What was supplied to this function
2267         dict.update(kwargs)
2268         # Parent constructor
2269         super(ULReq,self).__init__(**dict)
2270         if self.__class__ is ULReq:
2271             self._update(args,dict)
2272 
2273 
2274     def getfields(self):
2275         return self.__fields
2276 
2277 
2278     def _update(self, args, kwargs):
2279         super(ULReq,self)._update(args,kwargs)
2280         keys=kwargs.keys()
2281         for key in keys:
2282             if key in self.__fields:
2283                 setattr(self, key, kwargs[key])
2284                 del kwargs[key]
2285         # Were any unrecognized kwargs passed in?
2286         if __debug__:
2287             self._complainaboutunusedargs(ULReq,kwargs)
2288         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2289         # Make all P fields that haven't already been constructed
2290 
2291 
2292     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2293         'Writes this packet to the supplied buffer'
2294         self._bufferstartoffset=buf.getcurrentoffset()
2295         try: self.__field_cmd
2296         except:
2297             self.__field_cmd=UINT(**{'sizeinbytes': 1,  'default': 0xFE })
2298         self.__field_cmd.writetobuffer(buf)
2299         try: self.__field_unlock_code
2300         except:
2301             self.__field_unlock_code=UINT(**{'sizeinbytes': 1,  'default': 0x00 })
2302         self.__field_unlock_code.writetobuffer(buf)
2303         self.__field_unlock_key.writetobuffer(buf)
2304         try: self.__field_zero
2305         except:
2306             self.__field_zero=UINT(**{'sizeinbytes': 1,  'default': 0x00 })
2307         self.__field_zero.writetobuffer(buf)
2308         self._bufferendoffset=buf.getcurrentoffset()
2309         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2310 
2311 
2312     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2313         'Reads this packet from the supplied buffer'
2314         self._bufferstartoffset=buf.getcurrentoffset()
2315         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2316         self.__field_cmd=UINT(**{'sizeinbytes': 1,  'default': 0xFE })
2317         self.__field_cmd.readfrombuffer(buf)
2318         self.__field_unlock_code=UINT(**{'sizeinbytes': 1,  'default': 0x00 })
2319         self.__field_unlock_code.readfrombuffer(buf)
2320         self.__field_unlock_key=UINT(**{'sizeinbytes': 4})
2321         self.__field_unlock_key.readfrombuffer(buf)
2322         self.__field_zero=UINT(**{'sizeinbytes': 1,  'default': 0x00 })
2323         self.__field_zero.readfrombuffer(buf)
2324         self._bufferendoffset=buf.getcurrentoffset()
2325 
2326 
2327     def __getfield_cmd(self):
2328         try: self.__field_cmd
2329         except:
2330             self.__field_cmd=UINT(**{'sizeinbytes': 1,  'default': 0xFE })
2331         return self.__field_cmd.getvalue()
2332 
2333     def __setfield_cmd(self, value):
2334         if isinstance(value,UINT):
2335             self.__field_cmd=value
2336         else:
2337             self.__field_cmd=UINT(value,**{'sizeinbytes': 1,  'default': 0xFE })
2338 
2339     def __delfield_cmd(self): del self.__field_cmd
2340 
2341     cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None)
2342 
2343     def __getfield_unlock_code(self):
2344         try: self.__field_unlock_code
2345         except:
2346             self.__field_unlock_code=UINT(**{'sizeinbytes': 1,  'default': 0x00 })
2347         return self.__field_unlock_code.getvalue()
2348 
2349     def __setfield_unlock_code(self, value):
2350         if isinstance(value,UINT):
2351             self.__field_unlock_code=value
2352         else:
2353             self.__field_unlock_code=UINT(value,**{'sizeinbytes': 1,  'default': 0x00 })
2354 
2355     def __delfield_unlock_code(self): del self.__field_unlock_code
2356 
2357     unlock_code=property(__getfield_unlock_code, __setfield_unlock_code, __delfield_unlock_code, None)
2358 
2359     def __getfield_unlock_key(self):
2360         return self.__field_unlock_key.getvalue()
2361 
2362     def __setfield_unlock_key(self, value):
2363         if isinstance(value,UINT):
2364             self.__field_unlock_key=value
2365         else:
2366             self.__field_unlock_key=UINT(value,**{'sizeinbytes': 4})
2367 
2368     def __delfield_unlock_key(self): del self.__field_unlock_key
2369 
2370     unlock_key=property(__getfield_unlock_key, __setfield_unlock_key, __delfield_unlock_key, None)
2371 
2372     def __getfield_zero(self):
2373         try: self.__field_zero
2374         except:
2375             self.__field_zero=UINT(**{'sizeinbytes': 1,  'default': 0x00 })
2376         return self.__field_zero.getvalue()
2377 
2378     def __setfield_zero(self, value):
2379         if isinstance(value,UINT):
2380             self.__field_zero=value
2381         else:
2382             self.__field_zero=UINT(value,**{'sizeinbytes': 1,  'default': 0x00 })
2383 
2384     def __delfield_zero(self): del self.__field_zero
2385 
2386     zero=property(__getfield_zero, __setfield_zero, __delfield_zero, None)
2387 
2388     def iscontainer(self):
2389         return True
2390 
2391     def containerelements(self):
2392         yield ('cmd', self.__field_cmd, None)
2393         yield ('unlock_code', self.__field_unlock_code, None)
2394         yield ('unlock_key', self.__field_unlock_key, None)
2395         yield ('zero', self.__field_zero, None)
2396 
2397 
2398 
2399 
2400 class ULRes(BaseProtogenClass):
2401     ""
2402     __fields=['cmd', 'unlock_code', 'unlock_key', 'unlock_ok']
2403 
2404     def __init__(self, *args, **kwargs):
2405         dict={}
2406         # What was supplied to this function
2407         dict.update(kwargs)
2408         # Parent constructor
2409         super(ULRes,self).__init__(**dict)
2410         if self.__class__ is ULRes:
2411             self._update(args,dict)
2412 
2413 
2414     def getfields(self):
2415         return self.__fields
2416 
2417 
2418     def _update(self, args, kwargs):
2419         super(ULRes,self)._update(args,kwargs)
2420         keys=kwargs.keys()
2421         for key in keys:
2422             if key in self.__fields:
2423                 setattr(self, key, kwargs[key])
2424                 del kwargs[key]
2425         # Were any unrecognized kwargs passed in?
2426         if __debug__:
2427             self._complainaboutunusedargs(ULRes,kwargs)
2428         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2429         # Make all P fields that haven't already been constructed
2430 
2431 
2432     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2433         'Writes this packet to the supplied buffer'
2434         self._bufferstartoffset=buf.getcurrentoffset()
2435         self.__field_cmd.writetobuffer(buf)
2436         self.__field_unlock_code.writetobuffer(buf)
2437         self.__field_unlock_key.writetobuffer(buf)
2438         self.__field_unlock_ok.writetobuffer(buf)
2439         self._bufferendoffset=buf.getcurrentoffset()
2440         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2441 
2442 
2443     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2444         'Reads this packet from the supplied buffer'
2445         self._bufferstartoffset=buf.getcurrentoffset()
2446         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2447         self.__field_cmd=UINT(**{'sizeinbytes': 1})
2448         self.__field_cmd.readfrombuffer(buf)
2449         self.__field_unlock_code=UINT(**{'sizeinbytes': 1})
2450         self.__field_unlock_code.readfrombuffer(buf)
2451         self.__field_unlock_key=UINT(**{'sizeinbytes': 4})
2452         self.__field_unlock_key.readfrombuffer(buf)
2453         self.__field_unlock_ok=UINT(**{'sizeinbytes': 1})
2454         self.__field_unlock_ok.readfrombuffer(buf)
2455         self._bufferendoffset=buf.getcurrentoffset()
2456 
2457 
2458     def __getfield_cmd(self):
2459         return self.__field_cmd.getvalue()
2460 
2461     def __setfield_cmd(self, value):
2462         if isinstance(value,UINT):
2463             self.__field_cmd=value
2464         else:
2465             self.__field_cmd=UINT(value,**{'sizeinbytes': 1})
2466 
2467     def __delfield_cmd(self): del self.__field_cmd
2468 
2469     cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None)
2470 
2471     def __getfield_unlock_code(self):
2472         return self.__field_unlock_code.getvalue()
2473 
2474     def __setfield_unlock_code(self, value):
2475         if isinstance(value,UINT):
2476             self.__field_unlock_code=value
2477         else:
2478             self.__field_unlock_code=UINT(value,**{'sizeinbytes': 1})
2479 
2480     def __delfield_unlock_code(self): del self.__field_unlock_code
2481 
2482     unlock_code=property(__getfield_unlock_code, __setfield_unlock_code, __delfield_unlock_code, None)
2483 
2484     def __getfield_unlock_key(self):
2485         return self.__field_unlock_key.getvalue()
2486 
2487     def __setfield_unlock_key(self, value):
2488         if isinstance(value,UINT):
2489             self.__field_unlock_key=value
2490         else:
2491             self.__field_unlock_key=UINT(value,**{'sizeinbytes': 4})
2492 
2493     def __delfield_unlock_key(self): del self.__field_unlock_key
2494 
2495     unlock_key=property(__getfield_unlock_key, __setfield_unlock_key, __delfield_unlock_key, None)
2496 
2497     def __getfield_unlock_ok(self):
2498         return self.__field_unlock_ok.getvalue()
2499 
2500     def __setfield_unlock_ok(self, value):
2501         if isinstance(value,UINT):
2502             self.__field_unlock_ok=value
2503         else:
2504             self.__field_unlock_ok=UINT(value,**{'sizeinbytes': 1})
2505 
2506     def __delfield_unlock_ok(self): del self.__field_unlock_ok
2507 
2508     unlock_ok=property(__getfield_unlock_ok, __setfield_unlock_ok, __delfield_unlock_ok, None)
2509 
2510     def iscontainer(self):
2511         return True
2512 
2513     def containerelements(self):
2514         yield ('cmd', self.__field_cmd, None)
2515         yield ('unlock_code', self.__field_unlock_code, None)
2516         yield ('unlock_key', self.__field_unlock_key, None)
2517         yield ('unlock_ok', self.__field_unlock_ok, None)
2518 
2519 
2520 
2521 
2522 class textmemo(BaseProtogenClass):
2523     __fields=['text', 'dunno', 'memotime']
2524 
2525     def __init__(self, *args, **kwargs):
2526         dict={}
2527         # What was supplied to this function
2528         dict.update(kwargs)
2529         # Parent constructor
2530         super(textmemo,self).__init__(**dict)
2531         if self.__class__ is textmemo:
2532             self._update(args,dict)
2533 
2534 
2535     def getfields(self):
2536         return self.__fields
2537 
2538 
2539     def _update(self, args, kwargs):
2540         super(textmemo,self)._update(args,kwargs)
2541         keys=kwargs.keys()
2542         for key in keys:
2543             if key in self.__fields:
2544                 setattr(self, key, kwargs[key])
2545                 del kwargs[key]
2546         # Were any unrecognized kwargs passed in?
2547         if __debug__:
2548             self._complainaboutunusedargs(textmemo,kwargs)
2549         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2550         # Make all P fields that haven't already been constructed
2551 
2552 
2553     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2554         'Writes this packet to the supplied buffer'
2555         self._bufferstartoffset=buf.getcurrentoffset()
2556         self.__field_text.writetobuffer(buf)
2557         try: self.__field_dunno
2558         except:
2559             self.__field_dunno=UINT(**{'sizeinbytes': 4, 'default' : 0x1000000})
2560         self.__field_dunno.writetobuffer(buf)
2561         self.__field_memotime.writetobuffer(buf)
2562         self._bufferendoffset=buf.getcurrentoffset()
2563         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2564 
2565 
2566     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2567         'Reads this packet from the supplied buffer'
2568         self._bufferstartoffset=buf.getcurrentoffset()
2569         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2570         self.__field_text=USTRING(**{'sizeinbytes': 152, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False })
2571         self.__field_text.readfrombuffer(buf)
2572         self.__field_dunno=UINT(**{'sizeinbytes': 4, 'default' : 0x1000000})
2573         self.__field_dunno.readfrombuffer(buf)
2574         self.__field_memotime=LGCALDATE(**{'sizeinbytes': 4})
2575         self.__field_memotime.readfrombuffer(buf)
2576         self._bufferendoffset=buf.getcurrentoffset()
2577 
2578 
2579     def __getfield_text(self):
2580         return self.__field_text.getvalue()
2581 
2582     def __setfield_text(self, value):
2583         if isinstance(value,USTRING):
2584             self.__field_text=value
2585         else:
2586             self.__field_text=USTRING(value,**{'sizeinbytes': 152, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False })
2587 
2588     def __delfield_text(self): del self.__field_text
2589 
2590     text=property(__getfield_text, __setfield_text, __delfield_text, None)
2591 
2592     def __getfield_dunno(self):
2593         try: self.__field_dunno
2594         except:
2595             self.__field_dunno=UINT(**{'sizeinbytes': 4, 'default' : 0x1000000})
2596         return self.__field_dunno.getvalue()
2597 
2598     def __setfield_dunno(self, value):
2599         if isinstance(value,UINT):
2600             self.__field_dunno=value
2601         else:
2602             self.__field_dunno=UINT(value,**{'sizeinbytes': 4, 'default' : 0x1000000})
2603 
2604     def __delfield_dunno(self): del self.__field_dunno
2605 
2606     dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, None)
2607 
2608     def __getfield_memotime(self):
2609         return self.__field_memotime.getvalue()
2610 
2611     def __setfield_memotime(self, value):
2612         if isinstance(value,LGCALDATE):
2613             self.__field_memotime=value
2614         else:
2615             self.__field_memotime=LGCALDATE(value,**{'sizeinbytes': 4})
2616 
2617     def __delfield_memotime(self): del self.__field_memotime
2618 
2619     memotime=property(__getfield_memotime, __setfield_memotime, __delfield_memotime, None)
2620 
2621     def iscontainer(self):
2622         return True
2623 
2624     def containerelements(self):
2625         yield ('text', self.__field_text, None)
2626         yield ('dunno', self.__field_dunno, None)
2627         yield ('memotime', self.__field_memotime, None)
2628 
2629 
2630 
2631 
2632 class textmemofile(BaseProtogenClass):
2633     __fields=['itemcount', 'items']
2634 
2635     def __init__(self, *args, **kwargs):
2636         dict={}
2637         # What was supplied to this function
2638         dict.update(kwargs)
2639         # Parent constructor
2640         super(textmemofile,self).__init__(**dict)
2641         if self.__class__ is textmemofile:
2642             self._update(args,dict)
2643 
2644 
2645     def getfields(self):
2646         return self.__fields
2647 
2648 
2649     def _update(self, args, kwargs):
2650         super(textmemofile,self)._update(args,kwargs)
2651         keys=kwargs.keys()
2652         for key in keys:
2653             if key in self.__fields:
2654                 setattr(self, key, kwargs[key])
2655                 del kwargs[key]
2656         # Were any unrecognized kwargs passed in?
2657         if __debug__:
2658             self._complainaboutunusedargs(textmemofile,kwargs)
2659         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2660         # Make all P fields that haven't already been constructed
2661 
2662 
2663     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2664         'Writes this packet to the supplied buffer'
2665         self._bufferstartoffset=buf.getcurrentoffset()
2666         self.__field_itemcount.writetobuffer(buf)
2667         try: self.__field_items
2668         except:
2669             self.__field_items=LIST(**{ 'elementclass': textmemo })
2670         self.__field_items.writetobuffer(buf)
2671         self._bufferendoffset=buf.getcurrentoffset()
2672         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2673 
2674 
2675     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2676         'Reads this packet from the supplied buffer'
2677         self._bufferstartoffset=buf.getcurrentoffset()
2678         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2679         self.__field_itemcount=UINT(**{'sizeinbytes': 4})
2680         self.__field_itemcount.readfrombuffer(buf)
2681         self.__field_items=LIST(**{ 'elementclass': textmemo })
2682         self.__field_items.readfrombuffer(buf)
2683         self._bufferendoffset=buf.getcurrentoffset()
2684 
2685 
2686     def __getfield_itemcount(self):
2687         return self.__field_itemcount.getvalue()
2688 
2689     def __setfield_itemcount(self, value):
2690         if isinstance(value,UINT):
2691             self.__field_itemcount=value
2692         else:
2693             self.__field_itemcount=UINT(value,**{'sizeinbytes': 4})
2694 
2695     def __delfield_itemcount(self): del self.__field_itemcount
2696 
2697     itemcount=property(__getfield_itemcount, __setfield_itemcount, __delfield_itemcount, None)
2698 
2699     def __getfield_items(self):
2700         try: self.__field_items
2701         except:
2702             self.__field_items=LIST(**{ 'elementclass': textmemo })
2703         return self.__field_items.getvalue()
2704 
2705     def __setfield_items(self, value):
2706         if isinstance(value,LIST):
2707             self.__field_items=value
2708         else:
2709             self.__field_items=LIST(value,**{ 'elementclass': textmemo })
2710 
2711     def __delfield_items(self): del self.__field_items
2712 
2713     items=property(__getfield_items, __setfield_items, __delfield_items, None)
2714 
2715     def iscontainer(self):
2716         return True
2717 
2718     def containerelements(self):
2719         yield ('itemcount', self.__field_itemcount, None)
2720         yield ('items', self.__field_items, None)
2721 
2722 
2723 
2724 
2725