PyXR

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



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

Generated by PyXR 0.9.4