PyXR

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

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