PyXR

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

0001 # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE
0002 
0003 """Various descriptions of data specific to Sanyo RL-4930"""
0004 
0005 from prototypes import *
0006 
0007 # Make all sanyo stuff available in this module as well
0008 from p_sanyo import *
0009 from p_sanyomedia import *
0010 from p_sanyonewer import *
0011 
0012 # We use LSB for all integer like fields
0013 UINT=UINTlsb
0014 BOOL=BOOLlsb
0015 _NUMPBSLOTS=500
0016 _NUMSPEEDDIALS=8
0017 _NUMLONGNUMBERS=5
0018 _LONGPHONENUMBERLEN=30
0019 _NUMEVENTSLOTS=100
0020 _NUMCALLALARMSLOTS=15
0021 _NUMCALLHISTORY=20
0022 _MAXNUMBERLEN=32
0023 _MAXEMAILLEN=96
0024 HASRINGPICBUF=0
0025  
0026 class qcpheader(BaseProtogenClass):
0027     __fields=['readwrite', 'command', 'packettype']
0028 
0029     def __init__(self, *args, **kwargs):
0030         dict={}
0031         # User specified arguments in the packet description
0032         dict.update({'readwrite': 0x26})
0033         # What was supplied to this function
0034         dict.update(kwargs)
0035         # Parent constructor
0036         super(qcpheader,self).__init__(**dict)
0037         if self.__class__ is qcpheader:
0038             self._update(args,dict)
0039 
0040 
0041     def getfields(self):
0042         return self.__fields
0043 
0044 
0045     def _update(self, args, kwargs):
0046         super(qcpheader,self)._update(args,kwargs)
0047         keys=kwargs.keys()
0048         for key in keys:
0049             if key in self.__fields:
0050                 setattr(self, key, kwargs[key])
0051                 del kwargs[key]
0052         # Were any unrecognized kwargs passed in?
0053         if __debug__:
0054             self._complainaboutunusedargs(qcpheader,kwargs)
0055         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0056         # Make all P fields that haven't already been constructed
0057 
0058 
0059     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0060         'Writes this packet to the supplied buffer'
0061         self._bufferstartoffset=buf.getcurrentoffset()
0062         self.__field_readwrite.writetobuffer(buf)
0063         self.__field_command.writetobuffer(buf)
0064         self.__field_packettype.writetobuffer(buf)
0065         self._bufferendoffset=buf.getcurrentoffset()
0066         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0067 
0068 
0069     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0070         'Reads this packet from the supplied buffer'
0071         self._bufferstartoffset=buf.getcurrentoffset()
0072         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0073         self.__field_readwrite=UINT(**{'sizeinbytes': 1})
0074         self.__field_readwrite.readfrombuffer(buf)
0075         self.__field_command=UINT(**{'sizeinbytes': 1})
0076         self.__field_command.readfrombuffer(buf)
0077         self.__field_packettype=UINT(**{'sizeinbytes': 1})
0078         self.__field_packettype.readfrombuffer(buf)
0079         self._bufferendoffset=buf.getcurrentoffset()
0080 
0081 
0082     def __getfield_readwrite(self):
0083         return self.__field_readwrite.getvalue()
0084 
0085     def __setfield_readwrite(self, value):
0086         if isinstance(value,UINT):
0087             self.__field_readwrite=value
0088         else:
0089             self.__field_readwrite=UINT(value,**{'sizeinbytes': 1})
0090 
0091     def __delfield_readwrite(self): del self.__field_readwrite
0092 
0093     readwrite=property(__getfield_readwrite, __setfield_readwrite, __delfield_readwrite, None)
0094 
0095     def __getfield_command(self):
0096         return self.__field_command.getvalue()
0097 
0098     def __setfield_command(self, value):
0099         if isinstance(value,UINT):
0100             self.__field_command=value
0101         else:
0102             self.__field_command=UINT(value,**{'sizeinbytes': 1})
0103 
0104     def __delfield_command(self): del self.__field_command
0105 
0106     command=property(__getfield_command, __setfield_command, __delfield_command, None)
0107 
0108     def __getfield_packettype(self):
0109         return self.__field_packettype.getvalue()
0110 
0111     def __setfield_packettype(self, value):
0112         if isinstance(value,UINT):
0113             self.__field_packettype=value
0114         else:
0115             self.__field_packettype=UINT(value,**{'sizeinbytes': 1})
0116 
0117     def __delfield_packettype(self): del self.__field_packettype
0118 
0119     packettype=property(__getfield_packettype, __setfield_packettype, __delfield_packettype, None)
0120 
0121     def iscontainer(self):
0122         return True
0123 
0124     def containerelements(self):
0125         yield ('readwrite', self.__field_readwrite, None)
0126         yield ('command', self.__field_command, None)
0127         yield ('packettype', self.__field_packettype, None)
0128 
0129 
0130 
0131 
0132 class qcpwriteheader(BaseProtogenClass):
0133     __fields=['readwrite', 'command', 'packettype']
0134 
0135     def __init__(self, *args, **kwargs):
0136         dict={}
0137         # User specified arguments in the packet description
0138         dict.update({'readwrite': 0x27})
0139         # What was supplied to this function
0140         dict.update(kwargs)
0141         # Parent constructor
0142         super(qcpwriteheader,self).__init__(**dict)
0143         if self.__class__ is qcpwriteheader:
0144             self._update(args,dict)
0145 
0146 
0147     def getfields(self):
0148         return self.__fields
0149 
0150 
0151     def _update(self, args, kwargs):
0152         super(qcpwriteheader,self)._update(args,kwargs)
0153         keys=kwargs.keys()
0154         for key in keys:
0155             if key in self.__fields:
0156                 setattr(self, key, kwargs[key])
0157                 del kwargs[key]
0158         # Were any unrecognized kwargs passed in?
0159         if __debug__:
0160             self._complainaboutunusedargs(qcpwriteheader,kwargs)
0161         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0162         # Make all P fields that haven't already been constructed
0163 
0164 
0165     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0166         'Writes this packet to the supplied buffer'
0167         self._bufferstartoffset=buf.getcurrentoffset()
0168         self.__field_readwrite.writetobuffer(buf)
0169         self.__field_command.writetobuffer(buf)
0170         self.__field_packettype.writetobuffer(buf)
0171         self._bufferendoffset=buf.getcurrentoffset()
0172         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0173 
0174 
0175     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0176         'Reads this packet from the supplied buffer'
0177         self._bufferstartoffset=buf.getcurrentoffset()
0178         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0179         self.__field_readwrite=UINT(**{'sizeinbytes': 1})
0180         self.__field_readwrite.readfrombuffer(buf)
0181         self.__field_command=UINT(**{'sizeinbytes': 1})
0182         self.__field_command.readfrombuffer(buf)
0183         self.__field_packettype=UINT(**{'sizeinbytes': 1})
0184         self.__field_packettype.readfrombuffer(buf)
0185         self._bufferendoffset=buf.getcurrentoffset()
0186 
0187 
0188     def __getfield_readwrite(self):
0189         return self.__field_readwrite.getvalue()
0190 
0191     def __setfield_readwrite(self, value):
0192         if isinstance(value,UINT):
0193             self.__field_readwrite=value
0194         else:
0195             self.__field_readwrite=UINT(value,**{'sizeinbytes': 1})
0196 
0197     def __delfield_readwrite(self): del self.__field_readwrite
0198 
0199     readwrite=property(__getfield_readwrite, __setfield_readwrite, __delfield_readwrite, None)
0200 
0201     def __getfield_command(self):
0202         return self.__field_command.getvalue()
0203 
0204     def __setfield_command(self, value):
0205         if isinstance(value,UINT):
0206             self.__field_command=value
0207         else:
0208             self.__field_command=UINT(value,**{'sizeinbytes': 1})
0209 
0210     def __delfield_command(self): del self.__field_command
0211 
0212     command=property(__getfield_command, __setfield_command, __delfield_command, None)
0213 
0214     def __getfield_packettype(self):
0215         return self.__field_packettype.getvalue()
0216 
0217     def __setfield_packettype(self, value):
0218         if isinstance(value,UINT):
0219             self.__field_packettype=value
0220         else:
0221             self.__field_packettype=UINT(value,**{'sizeinbytes': 1})
0222 
0223     def __delfield_packettype(self): del self.__field_packettype
0224 
0225     packettype=property(__getfield_packettype, __setfield_packettype, __delfield_packettype, None)
0226 
0227     def iscontainer(self):
0228         return True
0229 
0230     def containerelements(self):
0231         yield ('readwrite', self.__field_readwrite, None)
0232         yield ('command', self.__field_command, None)
0233         yield ('packettype', self.__field_packettype, None)
0234 
0235 
0236 
0237 
0238 class pbsortbuffer(BaseProtogenClass):
0239     "Various arrays for sorting the phone book, speed dial, determining which"
0240     __fields=['startcommand', 'bufsize', 'comment', 'usedflags', 'slotsused', 'slotsused2', 'numemail', 'numurl', 'firsttypes', 'sortorder', 'pbfirstletters', 'sortorder2', 'speeddialindex', 'longnumbersindex', 'emails', 'emailfirstletters', 'urls', 'urlfirstletters', 'pad']
0241 
0242     def __init__(self, *args, **kwargs):
0243         dict={}
0244         # What was supplied to this function
0245         dict.update(kwargs)
0246         # Parent constructor
0247         super(pbsortbuffer,self).__init__(**dict)
0248         if self.__class__ is pbsortbuffer:
0249             self._update(args,dict)
0250 
0251 
0252     def getfields(self):
0253         return self.__fields
0254 
0255 
0256     def _update(self, args, kwargs):
0257         super(pbsortbuffer,self)._update(args,kwargs)
0258         keys=kwargs.keys()
0259         for key in keys:
0260             if key in self.__fields:
0261                 setattr(self, key, kwargs[key])
0262                 del kwargs[key]
0263         # Were any unrecognized kwargs passed in?
0264         if __debug__:
0265             self._complainaboutunusedargs(pbsortbuffer,kwargs)
0266         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0267         # Make all P fields that haven't already been constructed
0268         try: self.__field_startcommand
0269         except:
0270             self.__field_startcommand=UINT(**{'constant': 0x3c})
0271         try: self.__field_bufsize
0272         except:
0273             self.__field_bufsize=UINT(**{'constant': 7168})
0274         try: self.__field_comment
0275         except:
0276             self.__field_comment=USTRING(**{'default': "sort buffer"})
0277 
0278 
0279     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0280         'Writes this packet to the supplied buffer'
0281         self._bufferstartoffset=buf.getcurrentoffset()
0282         try: self.__field_usedflags
0283         except:
0284             self.__field_usedflags=LIST(**{'elementclass': _gen_p_sanyo4930_57, 'length': _NUMPBSLOTS, 'createdefault': True})
0285         self.__field_usedflags.writetobuffer(buf)
0286         self.__field_slotsused.writetobuffer(buf)
0287         self.__field_slotsused2.writetobuffer(buf)
0288         self.__field_numemail.writetobuffer(buf)
0289         self.__field_numurl.writetobuffer(buf)
0290         try: self.__field_firsttypes
0291         except:
0292             self.__field_firsttypes=LIST(**{'elementclass': _gen_p_sanyo4930_63, 'length': _NUMPBSLOTS})
0293         self.__field_firsttypes.writetobuffer(buf)
0294         try: self.__field_sortorder
0295         except:
0296             self.__field_sortorder=LIST(**{'elementclass': _gen_p_sanyo4930_65, 'length': _NUMPBSLOTS})
0297         self.__field_sortorder.writetobuffer(buf)
0298         self.__field_pbfirstletters.writetobuffer(buf)
0299         try: self.__field_sortorder2
0300         except:
0301             self.__field_sortorder2=LIST(**{'elementclass': _gen_p_sanyo4930_68, 'length': _NUMPBSLOTS})
0302         self.__field_sortorder2.writetobuffer(buf)
0303         try: self.__field_speeddialindex
0304         except:
0305             self.__field_speeddialindex=LIST(**{'elementclass': _gen_p_sanyo4930_70, 'length': _NUMSPEEDDIALS})
0306         self.__field_speeddialindex.writetobuffer(buf)
0307         try: self.__field_longnumbersindex
0308         except:
0309             self.__field_longnumbersindex=LIST(**{'elementclass': _gen_p_sanyo4930_72, 'length': _NUMLONGNUMBERS})
0310         self.__field_longnumbersindex.writetobuffer(buf)
0311         try: self.__field_emails
0312         except:
0313             self.__field_emails=LIST(**{'elementclass': _gen_p_sanyo4930_74, 'length': _NUMPBSLOTS})
0314         self.__field_emails.writetobuffer(buf)
0315         self.__field_emailfirstletters.writetobuffer(buf)
0316         try: self.__field_urls
0317         except:
0318             self.__field_urls=LIST(**{'elementclass': _gen_p_sanyo4930_77, 'length': _NUMPBSLOTS})
0319         self.__field_urls.writetobuffer(buf)
0320         self.__field_urlfirstletters.writetobuffer(buf)
0321         try: self.__field_pad
0322         except:
0323             self.__field_pad=UNKNOWN()
0324         self.__field_pad.writetobuffer(buf)
0325         self._bufferendoffset=buf.getcurrentoffset()
0326         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0327 
0328 
0329     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0330         'Reads this packet from the supplied buffer'
0331         self._bufferstartoffset=buf.getcurrentoffset()
0332         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0333         self.__field_usedflags=LIST(**{'elementclass': _gen_p_sanyo4930_57, 'length': _NUMPBSLOTS, 'createdefault': True})
0334         self.__field_usedflags.readfrombuffer(buf)
0335         self.__field_slotsused=UINT(**{'sizeinbytes': 2})
0336         self.__field_slotsused.readfrombuffer(buf)
0337         self.__field_slotsused2=UINT(**{'sizeinbytes': 2})
0338         self.__field_slotsused2.readfrombuffer(buf)
0339         self.__field_numemail=UINT(**{'sizeinbytes': 2})
0340         self.__field_numemail.readfrombuffer(buf)
0341         self.__field_numurl=UINT(**{'sizeinbytes': 2})
0342         self.__field_numurl.readfrombuffer(buf)
0343         self.__field_firsttypes=LIST(**{'elementclass': _gen_p_sanyo4930_63, 'length': _NUMPBSLOTS})
0344         self.__field_firsttypes.readfrombuffer(buf)
0345         self.__field_sortorder=LIST(**{'elementclass': _gen_p_sanyo4930_65, 'length': _NUMPBSLOTS})
0346         self.__field_sortorder.readfrombuffer(buf)
0347         self.__field_pbfirstletters=USTRING(**{'terminator': None, 'sizeinbytes': _NUMPBSLOTS})
0348         self.__field_pbfirstletters.readfrombuffer(buf)
0349         self.__field_sortorder2=LIST(**{'elementclass': _gen_p_sanyo4930_68, 'length': _NUMPBSLOTS})
0350         self.__field_sortorder2.readfrombuffer(buf)
0351         self.__field_speeddialindex=LIST(**{'elementclass': _gen_p_sanyo4930_70, 'length': _NUMSPEEDDIALS})
0352         self.__field_speeddialindex.readfrombuffer(buf)
0353         self.__field_longnumbersindex=LIST(**{'elementclass': _gen_p_sanyo4930_72, 'length': _NUMLONGNUMBERS})
0354         self.__field_longnumbersindex.readfrombuffer(buf)
0355         self.__field_emails=LIST(**{'elementclass': _gen_p_sanyo4930_74, 'length': _NUMPBSLOTS})
0356         self.__field_emails.readfrombuffer(buf)
0357         self.__field_emailfirstletters=USTRING(**{'terminator': None, 'sizeinbytes': _NUMPBSLOTS})
0358         self.__field_emailfirstletters.readfrombuffer(buf)
0359         self.__field_urls=LIST(**{'elementclass': _gen_p_sanyo4930_77, 'length': _NUMPBSLOTS})
0360         self.__field_urls.readfrombuffer(buf)
0361         self.__field_urlfirstletters=USTRING(**{'terminator': None, 'sizeinbytes': _NUMPBSLOTS})
0362         self.__field_urlfirstletters.readfrombuffer(buf)
0363         self.__field_pad=UNKNOWN()
0364         self.__field_pad.readfrombuffer(buf)
0365         self._bufferendoffset=buf.getcurrentoffset()
0366 
0367 
0368     def __getfield_startcommand(self):
0369         return self.__field_startcommand.getvalue()
0370 
0371     def __setfield_startcommand(self, value):
0372         if isinstance(value,UINT):
0373             self.__field_startcommand=value
0374         else:
0375             self.__field_startcommand=UINT(value,**{'constant': 0x3c})
0376 
0377     def __delfield_startcommand(self): del self.__field_startcommand
0378 
0379     startcommand=property(__getfield_startcommand, __setfield_startcommand, __delfield_startcommand, "Starting command for R/W buf parts")
0380 
0381     def __getfield_bufsize(self):
0382         return self.__field_bufsize.getvalue()
0383 
0384     def __setfield_bufsize(self, value):
0385         if isinstance(value,UINT):
0386             self.__field_bufsize=value
0387         else:
0388             self.__field_bufsize=UINT(value,**{'constant': 7168})
0389 
0390     def __delfield_bufsize(self): del self.__field_bufsize
0391 
0392     bufsize=property(__getfield_bufsize, __setfield_bufsize, __delfield_bufsize, None)
0393 
0394     def __getfield_comment(self):
0395         try: self.__field_comment
0396         except:
0397             self.__field_comment=USTRING(**{'default': "sort buffer"})
0398         return self.__field_comment.getvalue()
0399 
0400     def __setfield_comment(self, value):
0401         if isinstance(value,USTRING):
0402             self.__field_comment=value
0403         else:
0404             self.__field_comment=USTRING(value,**{'default': "sort buffer"})
0405 
0406     def __delfield_comment(self): del self.__field_comment
0407 
0408     comment=property(__getfield_comment, __setfield_comment, __delfield_comment, None)
0409 
0410     def __getfield_usedflags(self):
0411         try: self.__field_usedflags
0412         except:
0413             self.__field_usedflags=LIST(**{'elementclass': _gen_p_sanyo4930_57, 'length': _NUMPBSLOTS, 'createdefault': True})
0414         return self.__field_usedflags.getvalue()
0415 
0416     def __setfield_usedflags(self, value):
0417         if isinstance(value,LIST):
0418             self.__field_usedflags=value
0419         else:
0420             self.__field_usedflags=LIST(value,**{'elementclass': _gen_p_sanyo4930_57, 'length': _NUMPBSLOTS, 'createdefault': True})
0421 
0422     def __delfield_usedflags(self): del self.__field_usedflags
0423 
0424     usedflags=property(__getfield_usedflags, __setfield_usedflags, __delfield_usedflags, None)
0425 
0426     def __getfield_slotsused(self):
0427         return self.__field_slotsused.getvalue()
0428 
0429     def __setfield_slotsused(self, value):
0430         if isinstance(value,UINT):
0431             self.__field_slotsused=value
0432         else:
0433             self.__field_slotsused=UINT(value,**{'sizeinbytes': 2})
0434 
0435     def __delfield_slotsused(self): del self.__field_slotsused
0436 
0437     slotsused=property(__getfield_slotsused, __setfield_slotsused, __delfield_slotsused, None)
0438 
0439     def __getfield_slotsused2(self):
0440         return self.__field_slotsused2.getvalue()
0441 
0442     def __setfield_slotsused2(self, value):
0443         if isinstance(value,UINT):
0444             self.__field_slotsused2=value
0445         else:
0446             self.__field_slotsused2=UINT(value,**{'sizeinbytes': 2})
0447 
0448     def __delfield_slotsused2(self): del self.__field_slotsused2
0449 
0450     slotsused2=property(__getfield_slotsused2, __setfield_slotsused2, __delfield_slotsused2, "Always seems to be the same.  Why duplicated?")
0451 
0452     def __getfield_numemail(self):
0453         return self.__field_numemail.getvalue()
0454 
0455     def __setfield_numemail(self, value):
0456         if isinstance(value,UINT):
0457             self.__field_numemail=value
0458         else:
0459             self.__field_numemail=UINT(value,**{'sizeinbytes': 2})
0460 
0461     def __delfield_numemail(self): del self.__field_numemail
0462 
0463     numemail=property(__getfield_numemail, __setfield_numemail, __delfield_numemail, "Num of slots with email")
0464 
0465     def __getfield_numurl(self):
0466         return self.__field_numurl.getvalue()
0467 
0468     def __setfield_numurl(self, value):
0469         if isinstance(value,UINT):
0470             self.__field_numurl=value
0471         else:
0472             self.__field_numurl=UINT(value,**{'sizeinbytes': 2})
0473 
0474     def __delfield_numurl(self): del self.__field_numurl
0475 
0476     numurl=property(__getfield_numurl, __setfield_numurl, __delfield_numurl, "Num of slots with URL")
0477 
0478     def __getfield_firsttypes(self):
0479         try: self.__field_firsttypes
0480         except:
0481             self.__field_firsttypes=LIST(**{'elementclass': _gen_p_sanyo4930_63, 'length': _NUMPBSLOTS})
0482         return self.__field_firsttypes.getvalue()
0483 
0484     def __setfield_firsttypes(self, value):
0485         if isinstance(value,LIST):
0486             self.__field_firsttypes=value
0487         else:
0488             self.__field_firsttypes=LIST(value,**{'elementclass': _gen_p_sanyo4930_63, 'length': _NUMPBSLOTS})
0489 
0490     def __delfield_firsttypes(self): del self.__field_firsttypes
0491 
0492     firsttypes=property(__getfield_firsttypes, __setfield_firsttypes, __delfield_firsttypes, None)
0493 
0494     def __getfield_sortorder(self):
0495         try: self.__field_sortorder
0496         except:
0497             self.__field_sortorder=LIST(**{'elementclass': _gen_p_sanyo4930_65, 'length': _NUMPBSLOTS})
0498         return self.__field_sortorder.getvalue()
0499 
0500     def __setfield_sortorder(self, value):
0501         if isinstance(value,LIST):
0502             self.__field_sortorder=value
0503         else:
0504             self.__field_sortorder=LIST(value,**{'elementclass': _gen_p_sanyo4930_65, 'length': _NUMPBSLOTS})
0505 
0506     def __delfield_sortorder(self): del self.__field_sortorder
0507 
0508     sortorder=property(__getfield_sortorder, __setfield_sortorder, __delfield_sortorder, None)
0509 
0510     def __getfield_pbfirstletters(self):
0511         return self.__field_pbfirstletters.getvalue()
0512 
0513     def __setfield_pbfirstletters(self, value):
0514         if isinstance(value,USTRING):
0515             self.__field_pbfirstletters=value
0516         else:
0517             self.__field_pbfirstletters=USTRING(value,**{'terminator': None, 'sizeinbytes': _NUMPBSLOTS})
0518 
0519     def __delfield_pbfirstletters(self): del self.__field_pbfirstletters
0520 
0521     pbfirstletters=property(__getfield_pbfirstletters, __setfield_pbfirstletters, __delfield_pbfirstletters, None)
0522 
0523     def __getfield_sortorder2(self):
0524         try: self.__field_sortorder2
0525         except:
0526             self.__field_sortorder2=LIST(**{'elementclass': _gen_p_sanyo4930_68, 'length': _NUMPBSLOTS})
0527         return self.__field_sortorder2.getvalue()
0528 
0529     def __setfield_sortorder2(self, value):
0530         if isinstance(value,LIST):
0531             self.__field_sortorder2=value
0532         else:
0533             self.__field_sortorder2=LIST(value,**{'elementclass': _gen_p_sanyo4930_68, 'length': _NUMPBSLOTS})
0534 
0535     def __delfield_sortorder2(self): del self.__field_sortorder2
0536 
0537     sortorder2=property(__getfield_sortorder2, __setfield_sortorder2, __delfield_sortorder2, "Is this the same")
0538 
0539     def __getfield_speeddialindex(self):
0540         try: self.__field_speeddialindex
0541         except:
0542             self.__field_speeddialindex=LIST(**{'elementclass': _gen_p_sanyo4930_70, 'length': _NUMSPEEDDIALS})
0543         return self.__field_speeddialindex.getvalue()
0544 
0545     def __setfield_speeddialindex(self, value):
0546         if isinstance(value,LIST):
0547             self.__field_speeddialindex=value
0548         else:
0549             self.__field_speeddialindex=LIST(value,**{'elementclass': _gen_p_sanyo4930_70, 'length': _NUMSPEEDDIALS})
0550 
0551     def __delfield_speeddialindex(self): del self.__field_speeddialindex
0552 
0553     speeddialindex=property(__getfield_speeddialindex, __setfield_speeddialindex, __delfield_speeddialindex, None)
0554 
0555     def __getfield_longnumbersindex(self):
0556         try: self.__field_longnumbersindex
0557         except:
0558             self.__field_longnumbersindex=LIST(**{'elementclass': _gen_p_sanyo4930_72, 'length': _NUMLONGNUMBERS})
0559         return self.__field_longnumbersindex.getvalue()
0560 
0561     def __setfield_longnumbersindex(self, value):
0562         if isinstance(value,LIST):
0563             self.__field_longnumbersindex=value
0564         else:
0565             self.__field_longnumbersindex=LIST(value,**{'elementclass': _gen_p_sanyo4930_72, 'length': _NUMLONGNUMBERS})
0566 
0567     def __delfield_longnumbersindex(self): del self.__field_longnumbersindex
0568 
0569     longnumbersindex=property(__getfield_longnumbersindex, __setfield_longnumbersindex, __delfield_longnumbersindex, None)
0570 
0571     def __getfield_emails(self):
0572         try: self.__field_emails
0573         except:
0574             self.__field_emails=LIST(**{'elementclass': _gen_p_sanyo4930_74, 'length': _NUMPBSLOTS})
0575         return self.__field_emails.getvalue()
0576 
0577     def __setfield_emails(self, value):
0578         if isinstance(value,LIST):
0579             self.__field_emails=value
0580         else:
0581             self.__field_emails=LIST(value,**{'elementclass': _gen_p_sanyo4930_74, 'length': _NUMPBSLOTS})
0582 
0583     def __delfield_emails(self): del self.__field_emails
0584 
0585     emails=property(__getfield_emails, __setfield_emails, __delfield_emails, "Sorted list of slots with Email")
0586 
0587     def __getfield_emailfirstletters(self):
0588         return self.__field_emailfirstletters.getvalue()
0589 
0590     def __setfield_emailfirstletters(self, value):
0591         if isinstance(value,USTRING):
0592             self.__field_emailfirstletters=value
0593         else:
0594             self.__field_emailfirstletters=USTRING(value,**{'terminator': None, 'sizeinbytes': _NUMPBSLOTS})
0595 
0596     def __delfield_emailfirstletters(self): del self.__field_emailfirstletters
0597 
0598     emailfirstletters=property(__getfield_emailfirstletters, __setfield_emailfirstletters, __delfield_emailfirstletters, "First letters in sort order")
0599 
0600     def __getfield_urls(self):
0601         try: self.__field_urls
0602         except:
0603             self.__field_urls=LIST(**{'elementclass': _gen_p_sanyo4930_77, 'length': _NUMPBSLOTS})
0604         return self.__field_urls.getvalue()
0605 
0606     def __setfield_urls(self, value):
0607         if isinstance(value,LIST):
0608             self.__field_urls=value
0609         else:
0610             self.__field_urls=LIST(value,**{'elementclass': _gen_p_sanyo4930_77, 'length': _NUMPBSLOTS})
0611 
0612     def __delfield_urls(self): del self.__field_urls
0613 
0614     urls=property(__getfield_urls, __setfield_urls, __delfield_urls, "Sorted list of slots with a URL")
0615 
0616     def __getfield_urlfirstletters(self):
0617         return self.__field_urlfirstletters.getvalue()
0618 
0619     def __setfield_urlfirstletters(self, value):
0620         if isinstance(value,USTRING):
0621             self.__field_urlfirstletters=value
0622         else:
0623             self.__field_urlfirstletters=USTRING(value,**{'terminator': None, 'sizeinbytes': _NUMPBSLOTS})
0624 
0625     def __delfield_urlfirstletters(self): del self.__field_urlfirstletters
0626 
0627     urlfirstletters=property(__getfield_urlfirstletters, __setfield_urlfirstletters, __delfield_urlfirstletters, "First letters in sort order")
0628 
0629     def __getfield_pad(self):
0630         try: self.__field_pad
0631         except:
0632             self.__field_pad=UNKNOWN()
0633         return self.__field_pad.getvalue()
0634 
0635     def __setfield_pad(self, value):
0636         if isinstance(value,UNKNOWN):
0637             self.__field_pad=value
0638         else:
0639             self.__field_pad=UNKNOWN(value,)
0640 
0641     def __delfield_pad(self): del self.__field_pad
0642 
0643     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
0644 
0645     def iscontainer(self):
0646         return True
0647 
0648     def containerelements(self):
0649         yield ('startcommand', self.__field_startcommand, "Starting command for R/W buf parts")
0650         yield ('bufsize', self.__field_bufsize, None)
0651         yield ('comment', self.__field_comment, None)
0652         yield ('usedflags', self.__field_usedflags, None)
0653         yield ('slotsused', self.__field_slotsused, None)
0654         yield ('slotsused2', self.__field_slotsused2, "Always seems to be the same.  Why duplicated?")
0655         yield ('numemail', self.__field_numemail, "Num of slots with email")
0656         yield ('numurl', self.__field_numurl, "Num of slots with URL")
0657         yield ('firsttypes', self.__field_firsttypes, None)
0658         yield ('sortorder', self.__field_sortorder, None)
0659         yield ('pbfirstletters', self.__field_pbfirstletters, None)
0660         yield ('sortorder2', self.__field_sortorder2, "Is this the same")
0661         yield ('speeddialindex', self.__field_speeddialindex, None)
0662         yield ('longnumbersindex', self.__field_longnumbersindex, None)
0663         yield ('emails', self.__field_emails, "Sorted list of slots with Email")
0664         yield ('emailfirstletters', self.__field_emailfirstletters, "First letters in sort order")
0665         yield ('urls', self.__field_urls, "Sorted list of slots with a URL")
0666         yield ('urlfirstletters', self.__field_urlfirstletters, "First letters in sort order")
0667         yield ('pad', self.__field_pad, None)
0668 
0669 
0670 
0671 
0672 class _gen_p_sanyo4930_57(BaseProtogenClass):
0673     'Anonymous inner class'
0674     __fields=['used']
0675 
0676     def __init__(self, *args, **kwargs):
0677         dict={}
0678         # What was supplied to this function
0679         dict.update(kwargs)
0680         # Parent constructor
0681         super(_gen_p_sanyo4930_57,self).__init__(**dict)
0682         if self.__class__ is _gen_p_sanyo4930_57:
0683             self._update(args,dict)
0684 
0685 
0686     def getfields(self):
0687         return self.__fields
0688 
0689 
0690     def _update(self, args, kwargs):
0691         super(_gen_p_sanyo4930_57,self)._update(args,kwargs)
0692         keys=kwargs.keys()
0693         for key in keys:
0694             if key in self.__fields:
0695                 setattr(self, key, kwargs[key])
0696                 del kwargs[key]
0697         # Were any unrecognized kwargs passed in?
0698         if __debug__:
0699             self._complainaboutunusedargs(_gen_p_sanyo4930_57,kwargs)
0700         if len(args):
0701             dict2={'sizeinbytes': 1}
0702             dict2.update(kwargs)
0703             kwargs=dict2
0704             self.__field_used=UINT(*args,**dict2)
0705         # Make all P fields that haven't already been constructed
0706 
0707 
0708     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0709         'Writes this packet to the supplied buffer'
0710         self._bufferstartoffset=buf.getcurrentoffset()
0711         self.__field_used.writetobuffer(buf)
0712         self._bufferendoffset=buf.getcurrentoffset()
0713         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0714 
0715 
0716     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0717         'Reads this packet from the supplied buffer'
0718         self._bufferstartoffset=buf.getcurrentoffset()
0719         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0720         self.__field_used=UINT(**{'sizeinbytes': 1})
0721         self.__field_used.readfrombuffer(buf)
0722         self._bufferendoffset=buf.getcurrentoffset()
0723 
0724 
0725     def __getfield_used(self):
0726         return self.__field_used.getvalue()
0727 
0728     def __setfield_used(self, value):
0729         if isinstance(value,UINT):
0730             self.__field_used=value
0731         else:
0732             self.__field_used=UINT(value,**{'sizeinbytes': 1})
0733 
0734     def __delfield_used(self): del self.__field_used
0735 
0736     used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use")
0737 
0738     def iscontainer(self):
0739         return True
0740 
0741     def containerelements(self):
0742         yield ('used', self.__field_used, "1 if slot in use")
0743 
0744 
0745 
0746 
0747 class _gen_p_sanyo4930_63(BaseProtogenClass):
0748     'Anonymous inner class'
0749     __fields=['firsttype']
0750 
0751     def __init__(self, *args, **kwargs):
0752         dict={}
0753         # What was supplied to this function
0754         dict.update(kwargs)
0755         # Parent constructor
0756         super(_gen_p_sanyo4930_63,self).__init__(**dict)
0757         if self.__class__ is _gen_p_sanyo4930_63:
0758             self._update(args,dict)
0759 
0760 
0761     def getfields(self):
0762         return self.__fields
0763 
0764 
0765     def _update(self, args, kwargs):
0766         super(_gen_p_sanyo4930_63,self)._update(args,kwargs)
0767         keys=kwargs.keys()
0768         for key in keys:
0769             if key in self.__fields:
0770                 setattr(self, key, kwargs[key])
0771                 del kwargs[key]
0772         # Were any unrecognized kwargs passed in?
0773         if __debug__:
0774             self._complainaboutunusedargs(_gen_p_sanyo4930_63,kwargs)
0775         if len(args):
0776             dict2={'sizeinbytes': 1}
0777             dict2.update(kwargs)
0778             kwargs=dict2
0779             self.__field_firsttype=UINT(*args,**dict2)
0780         # Make all P fields that haven't already been constructed
0781 
0782 
0783     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0784         'Writes this packet to the supplied buffer'
0785         self._bufferstartoffset=buf.getcurrentoffset()
0786         self.__field_firsttype.writetobuffer(buf)
0787         self._bufferendoffset=buf.getcurrentoffset()
0788         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0789 
0790 
0791     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0792         'Reads this packet from the supplied buffer'
0793         self._bufferstartoffset=buf.getcurrentoffset()
0794         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0795         self.__field_firsttype=UINT(**{'sizeinbytes': 1})
0796         self.__field_firsttype.readfrombuffer(buf)
0797         self._bufferendoffset=buf.getcurrentoffset()
0798 
0799 
0800     def __getfield_firsttype(self):
0801         return self.__field_firsttype.getvalue()
0802 
0803     def __setfield_firsttype(self, value):
0804         if isinstance(value,UINT):
0805             self.__field_firsttype=value
0806         else:
0807             self.__field_firsttype=UINT(value,**{'sizeinbytes': 1})
0808 
0809     def __delfield_firsttype(self): del self.__field_firsttype
0810 
0811     firsttype=property(__getfield_firsttype, __setfield_firsttype, __delfield_firsttype, "First phone number type in each slot")
0812 
0813     def iscontainer(self):
0814         return True
0815 
0816     def containerelements(self):
0817         yield ('firsttype', self.__field_firsttype, "First phone number type in each slot")
0818 
0819 
0820 
0821 
0822 class _gen_p_sanyo4930_65(BaseProtogenClass):
0823     'Anonymous inner class'
0824     __fields=['pbslot']
0825 
0826     def __init__(self, *args, **kwargs):
0827         dict={}
0828         # What was supplied to this function
0829         dict.update(kwargs)
0830         # Parent constructor
0831         super(_gen_p_sanyo4930_65,self).__init__(**dict)
0832         if self.__class__ is _gen_p_sanyo4930_65:
0833             self._update(args,dict)
0834 
0835 
0836     def getfields(self):
0837         return self.__fields
0838 
0839 
0840     def _update(self, args, kwargs):
0841         super(_gen_p_sanyo4930_65,self)._update(args,kwargs)
0842         keys=kwargs.keys()
0843         for key in keys:
0844             if key in self.__fields:
0845                 setattr(self, key, kwargs[key])
0846                 del kwargs[key]
0847         # Were any unrecognized kwargs passed in?
0848         if __debug__:
0849             self._complainaboutunusedargs(_gen_p_sanyo4930_65,kwargs)
0850         if len(args):
0851             dict2={'sizeinbytes': 2, 'default': 0xffff}
0852             dict2.update(kwargs)
0853             kwargs=dict2
0854             self.__field_pbslot=UINT(*args,**dict2)
0855         # Make all P fields that haven't already been constructed
0856 
0857 
0858     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0859         'Writes this packet to the supplied buffer'
0860         self._bufferstartoffset=buf.getcurrentoffset()
0861         self.__field_pbslot.writetobuffer(buf)
0862         self._bufferendoffset=buf.getcurrentoffset()
0863         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0864 
0865 
0866     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0867         'Reads this packet from the supplied buffer'
0868         self._bufferstartoffset=buf.getcurrentoffset()
0869         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0870         self.__field_pbslot=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
0871         self.__field_pbslot.readfrombuffer(buf)
0872         self._bufferendoffset=buf.getcurrentoffset()
0873 
0874 
0875     def __getfield_pbslot(self):
0876         return self.__field_pbslot.getvalue()
0877 
0878     def __setfield_pbslot(self, value):
0879         if isinstance(value,UINT):
0880             self.__field_pbslot=value
0881         else:
0882             self.__field_pbslot=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff})
0883 
0884     def __delfield_pbslot(self): del self.__field_pbslot
0885 
0886     pbslot=property(__getfield_pbslot, __setfield_pbslot, __delfield_pbslot, None)
0887 
0888     def iscontainer(self):
0889         return True
0890 
0891     def containerelements(self):
0892         yield ('pbslot', self.__field_pbslot, None)
0893 
0894 
0895 
0896 
0897 class _gen_p_sanyo4930_68(BaseProtogenClass):
0898     'Anonymous inner class'
0899     __fields=['pbslot']
0900 
0901     def __init__(self, *args, **kwargs):
0902         dict={}
0903         # What was supplied to this function
0904         dict.update(kwargs)
0905         # Parent constructor
0906         super(_gen_p_sanyo4930_68,self).__init__(**dict)
0907         if self.__class__ is _gen_p_sanyo4930_68:
0908             self._update(args,dict)
0909 
0910 
0911     def getfields(self):
0912         return self.__fields
0913 
0914 
0915     def _update(self, args, kwargs):
0916         super(_gen_p_sanyo4930_68,self)._update(args,kwargs)
0917         keys=kwargs.keys()
0918         for key in keys:
0919             if key in self.__fields:
0920                 setattr(self, key, kwargs[key])
0921                 del kwargs[key]
0922         # Were any unrecognized kwargs passed in?
0923         if __debug__:
0924             self._complainaboutunusedargs(_gen_p_sanyo4930_68,kwargs)
0925         if len(args):
0926             dict2={'sizeinbytes': 2, 'default': 0xffff}
0927             dict2.update(kwargs)
0928             kwargs=dict2
0929             self.__field_pbslot=UINT(*args,**dict2)
0930         # Make all P fields that haven't already been constructed
0931 
0932 
0933     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0934         'Writes this packet to the supplied buffer'
0935         self._bufferstartoffset=buf.getcurrentoffset()
0936         self.__field_pbslot.writetobuffer(buf)
0937         self._bufferendoffset=buf.getcurrentoffset()
0938         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0939 
0940 
0941     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0942         'Reads this packet from the supplied buffer'
0943         self._bufferstartoffset=buf.getcurrentoffset()
0944         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0945         self.__field_pbslot=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
0946         self.__field_pbslot.readfrombuffer(buf)
0947         self._bufferendoffset=buf.getcurrentoffset()
0948 
0949 
0950     def __getfield_pbslot(self):
0951         return self.__field_pbslot.getvalue()
0952 
0953     def __setfield_pbslot(self, value):
0954         if isinstance(value,UINT):
0955             self.__field_pbslot=value
0956         else:
0957             self.__field_pbslot=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff})
0958 
0959     def __delfield_pbslot(self): del self.__field_pbslot
0960 
0961     pbslot=property(__getfield_pbslot, __setfield_pbslot, __delfield_pbslot, None)
0962 
0963     def iscontainer(self):
0964         return True
0965 
0966     def containerelements(self):
0967         yield ('pbslot', self.__field_pbslot, None)
0968 
0969 
0970 
0971 
0972 class _gen_p_sanyo4930_70(BaseProtogenClass):
0973     'Anonymous inner class'
0974     __fields=['pbslotandtype']
0975 
0976     def __init__(self, *args, **kwargs):
0977         dict={}
0978         # What was supplied to this function
0979         dict.update(kwargs)
0980         # Parent constructor
0981         super(_gen_p_sanyo4930_70,self).__init__(**dict)
0982         if self.__class__ is _gen_p_sanyo4930_70:
0983             self._update(args,dict)
0984 
0985 
0986     def getfields(self):
0987         return self.__fields
0988 
0989 
0990     def _update(self, args, kwargs):
0991         super(_gen_p_sanyo4930_70,self)._update(args,kwargs)
0992         keys=kwargs.keys()
0993         for key in keys:
0994             if key in self.__fields:
0995                 setattr(self, key, kwargs[key])
0996                 del kwargs[key]
0997         # Were any unrecognized kwargs passed in?
0998         if __debug__:
0999             self._complainaboutunusedargs(_gen_p_sanyo4930_70,kwargs)
1000         if len(args):
1001             dict2={'sizeinbytes': 2, 'default': 0xffff}
1002             dict2.update(kwargs)
1003             kwargs=dict2
1004             self.__field_pbslotandtype=UINT(*args,**dict2)
1005         # Make all P fields that haven't already been constructed
1006 
1007 
1008     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1009         'Writes this packet to the supplied buffer'
1010         self._bufferstartoffset=buf.getcurrentoffset()
1011         self.__field_pbslotandtype.writetobuffer(buf)
1012         self._bufferendoffset=buf.getcurrentoffset()
1013         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1014 
1015 
1016     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1017         'Reads this packet from the supplied buffer'
1018         self._bufferstartoffset=buf.getcurrentoffset()
1019         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1020         self.__field_pbslotandtype=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
1021         self.__field_pbslotandtype.readfrombuffer(buf)
1022         self._bufferendoffset=buf.getcurrentoffset()
1023 
1024 
1025     def __getfield_pbslotandtype(self):
1026         return self.__field_pbslotandtype.getvalue()
1027 
1028     def __setfield_pbslotandtype(self, value):
1029         if isinstance(value,UINT):
1030             self.__field_pbslotandtype=value
1031         else:
1032             self.__field_pbslotandtype=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff})
1033 
1034     def __delfield_pbslotandtype(self): del self.__field_pbslotandtype
1035 
1036     pbslotandtype=property(__getfield_pbslotandtype, __setfield_pbslotandtype, __delfield_pbslotandtype, None)
1037 
1038     def iscontainer(self):
1039         return True
1040 
1041     def containerelements(self):
1042         yield ('pbslotandtype', self.__field_pbslotandtype, None)
1043 
1044 
1045 
1046 
1047 class _gen_p_sanyo4930_72(BaseProtogenClass):
1048     'Anonymous inner class'
1049     __fields=['pbslotandtype']
1050 
1051     def __init__(self, *args, **kwargs):
1052         dict={}
1053         # What was supplied to this function
1054         dict.update(kwargs)
1055         # Parent constructor
1056         super(_gen_p_sanyo4930_72,self).__init__(**dict)
1057         if self.__class__ is _gen_p_sanyo4930_72:
1058             self._update(args,dict)
1059 
1060 
1061     def getfields(self):
1062         return self.__fields
1063 
1064 
1065     def _update(self, args, kwargs):
1066         super(_gen_p_sanyo4930_72,self)._update(args,kwargs)
1067         keys=kwargs.keys()
1068         for key in keys:
1069             if key in self.__fields:
1070                 setattr(self, key, kwargs[key])
1071                 del kwargs[key]
1072         # Were any unrecognized kwargs passed in?
1073         if __debug__:
1074             self._complainaboutunusedargs(_gen_p_sanyo4930_72,kwargs)
1075         if len(args):
1076             dict2={'sizeinbytes': 2, 'default': 0xffff}
1077             dict2.update(kwargs)
1078             kwargs=dict2
1079             self.__field_pbslotandtype=UINT(*args,**dict2)
1080         # Make all P fields that haven't already been constructed
1081 
1082 
1083     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1084         'Writes this packet to the supplied buffer'
1085         self._bufferstartoffset=buf.getcurrentoffset()
1086         self.__field_pbslotandtype.writetobuffer(buf)
1087         self._bufferendoffset=buf.getcurrentoffset()
1088         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1089 
1090 
1091     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1092         'Reads this packet from the supplied buffer'
1093         self._bufferstartoffset=buf.getcurrentoffset()
1094         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1095         self.__field_pbslotandtype=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
1096         self.__field_pbslotandtype.readfrombuffer(buf)
1097         self._bufferendoffset=buf.getcurrentoffset()
1098 
1099 
1100     def __getfield_pbslotandtype(self):
1101         return self.__field_pbslotandtype.getvalue()
1102 
1103     def __setfield_pbslotandtype(self, value):
1104         if isinstance(value,UINT):
1105             self.__field_pbslotandtype=value
1106         else:
1107             self.__field_pbslotandtype=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff})
1108 
1109     def __delfield_pbslotandtype(self): del self.__field_pbslotandtype
1110 
1111     pbslotandtype=property(__getfield_pbslotandtype, __setfield_pbslotandtype, __delfield_pbslotandtype, None)
1112 
1113     def iscontainer(self):
1114         return True
1115 
1116     def containerelements(self):
1117         yield ('pbslotandtype', self.__field_pbslotandtype, None)
1118 
1119 
1120 
1121 
1122 class _gen_p_sanyo4930_74(BaseProtogenClass):
1123     'Anonymous inner class'
1124     __fields=['pbslot']
1125 
1126     def __init__(self, *args, **kwargs):
1127         dict={}
1128         # What was supplied to this function
1129         dict.update(kwargs)
1130         # Parent constructor
1131         super(_gen_p_sanyo4930_74,self).__init__(**dict)
1132         if self.__class__ is _gen_p_sanyo4930_74:
1133             self._update(args,dict)
1134 
1135 
1136     def getfields(self):
1137         return self.__fields
1138 
1139 
1140     def _update(self, args, kwargs):
1141         super(_gen_p_sanyo4930_74,self)._update(args,kwargs)
1142         keys=kwargs.keys()
1143         for key in keys:
1144             if key in self.__fields:
1145                 setattr(self, key, kwargs[key])
1146                 del kwargs[key]
1147         # Were any unrecognized kwargs passed in?
1148         if __debug__:
1149             self._complainaboutunusedargs(_gen_p_sanyo4930_74,kwargs)
1150         if len(args):
1151             dict2={'sizeinbytes': 2, 'default': 0xffff}
1152             dict2.update(kwargs)
1153             kwargs=dict2
1154             self.__field_pbslot=UINT(*args,**dict2)
1155         # Make all P fields that haven't already been constructed
1156 
1157 
1158     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1159         'Writes this packet to the supplied buffer'
1160         self._bufferstartoffset=buf.getcurrentoffset()
1161         self.__field_pbslot.writetobuffer(buf)
1162         self._bufferendoffset=buf.getcurrentoffset()
1163         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1164 
1165 
1166     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1167         'Reads this packet from the supplied buffer'
1168         self._bufferstartoffset=buf.getcurrentoffset()
1169         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1170         self.__field_pbslot=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
1171         self.__field_pbslot.readfrombuffer(buf)
1172         self._bufferendoffset=buf.getcurrentoffset()
1173 
1174 
1175     def __getfield_pbslot(self):
1176         return self.__field_pbslot.getvalue()
1177 
1178     def __setfield_pbslot(self, value):
1179         if isinstance(value,UINT):
1180             self.__field_pbslot=value
1181         else:
1182             self.__field_pbslot=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff})
1183 
1184     def __delfield_pbslot(self): del self.__field_pbslot
1185 
1186     pbslot=property(__getfield_pbslot, __setfield_pbslot, __delfield_pbslot, None)
1187 
1188     def iscontainer(self):
1189         return True
1190 
1191     def containerelements(self):
1192         yield ('pbslot', self.__field_pbslot, None)
1193 
1194 
1195 
1196 
1197 class _gen_p_sanyo4930_77(BaseProtogenClass):
1198     'Anonymous inner class'
1199     __fields=['pbslot']
1200 
1201     def __init__(self, *args, **kwargs):
1202         dict={}
1203         # What was supplied to this function
1204         dict.update(kwargs)
1205         # Parent constructor
1206         super(_gen_p_sanyo4930_77,self).__init__(**dict)
1207         if self.__class__ is _gen_p_sanyo4930_77:
1208             self._update(args,dict)
1209 
1210 
1211     def getfields(self):
1212         return self.__fields
1213 
1214 
1215     def _update(self, args, kwargs):
1216         super(_gen_p_sanyo4930_77,self)._update(args,kwargs)
1217         keys=kwargs.keys()
1218         for key in keys:
1219             if key in self.__fields:
1220                 setattr(self, key, kwargs[key])
1221                 del kwargs[key]
1222         # Were any unrecognized kwargs passed in?
1223         if __debug__:
1224             self._complainaboutunusedargs(_gen_p_sanyo4930_77,kwargs)
1225         if len(args):
1226             dict2={'sizeinbytes': 2, 'default': 0xffff}
1227             dict2.update(kwargs)
1228             kwargs=dict2
1229             self.__field_pbslot=UINT(*args,**dict2)
1230         # Make all P fields that haven't already been constructed
1231 
1232 
1233     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1234         'Writes this packet to the supplied buffer'
1235         self._bufferstartoffset=buf.getcurrentoffset()
1236         self.__field_pbslot.writetobuffer(buf)
1237         self._bufferendoffset=buf.getcurrentoffset()
1238         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1239 
1240 
1241     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1242         'Reads this packet from the supplied buffer'
1243         self._bufferstartoffset=buf.getcurrentoffset()
1244         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1245         self.__field_pbslot=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
1246         self.__field_pbslot.readfrombuffer(buf)
1247         self._bufferendoffset=buf.getcurrentoffset()
1248 
1249 
1250     def __getfield_pbslot(self):
1251         return self.__field_pbslot.getvalue()
1252 
1253     def __setfield_pbslot(self, value):
1254         if isinstance(value,UINT):
1255             self.__field_pbslot=value
1256         else:
1257             self.__field_pbslot=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff})
1258 
1259     def __delfield_pbslot(self): del self.__field_pbslot
1260 
1261     pbslot=property(__getfield_pbslot, __setfield_pbslot, __delfield_pbslot, None)
1262 
1263     def iscontainer(self):
1264         return True
1265 
1266     def containerelements(self):
1267         yield ('pbslot', self.__field_pbslot, None)
1268 
1269 
1270 
1271 
1272 class calleridbuffer(BaseProtogenClass):
1273     "Index so that phone can show a name instead of number"
1274     __fields=['maxentries', 'startcommand', 'bufsize', 'comment', 'numentries', 'items', 'pad']
1275 
1276     def __init__(self, *args, **kwargs):
1277         dict={}
1278         # What was supplied to this function
1279         dict.update(kwargs)
1280         # Parent constructor
1281         super(calleridbuffer,self).__init__(**dict)
1282         if self.__class__ is calleridbuffer:
1283             self._update(args,dict)
1284 
1285 
1286     def getfields(self):
1287         return self.__fields
1288 
1289 
1290     def _update(self, args, kwargs):
1291         super(calleridbuffer,self)._update(args,kwargs)
1292         keys=kwargs.keys()
1293         for key in keys:
1294             if key in self.__fields:
1295                 setattr(self, key, kwargs[key])
1296                 del kwargs[key]
1297         # Were any unrecognized kwargs passed in?
1298         if __debug__:
1299             self._complainaboutunusedargs(calleridbuffer,kwargs)
1300         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1301         # Make all P fields that haven't already been constructed
1302         try: self.__field_maxentries
1303         except:
1304             self.__field_maxentries=UINT(**{'constant': 700})
1305         try: self.__field_startcommand
1306         except:
1307             self.__field_startcommand=UINT(**{'constant': 0x46})
1308         try: self.__field_bufsize
1309         except:
1310             self.__field_bufsize=UINT(**{'constant': 9216})
1311         try: self.__field_comment
1312         except:
1313             self.__field_comment=USTRING(**{'default': "callerid"})
1314 
1315 
1316     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1317         'Writes this packet to the supplied buffer'
1318         self._bufferstartoffset=buf.getcurrentoffset()
1319         self.__field_numentries.writetobuffer(buf)
1320         try: self.__field_items
1321         except:
1322             self.__field_items=LIST(**{'length': self.maxentries, 'elementclass': calleridentry, 'createdefault': True})
1323         self.__field_items.writetobuffer(buf)
1324         try: self.__field_pad
1325         except:
1326             self.__field_pad=UNKNOWN()
1327         self.__field_pad.writetobuffer(buf)
1328         self._bufferendoffset=buf.getcurrentoffset()
1329         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1330 
1331 
1332     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1333         'Reads this packet from the supplied buffer'
1334         self._bufferstartoffset=buf.getcurrentoffset()
1335         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1336         self.__field_numentries=UINT(**{'sizeinbytes': 2})
1337         self.__field_numentries.readfrombuffer(buf)
1338         self.__field_items=LIST(**{'length': self.maxentries, 'elementclass': calleridentry, 'createdefault': True})
1339         self.__field_items.readfrombuffer(buf)
1340         self.__field_pad=UNKNOWN()
1341         self.__field_pad.readfrombuffer(buf)
1342         self._bufferendoffset=buf.getcurrentoffset()
1343 
1344 
1345     def __getfield_maxentries(self):
1346         return self.__field_maxentries.getvalue()
1347 
1348     def __setfield_maxentries(self, value):
1349         if isinstance(value,UINT):
1350             self.__field_maxentries=value
1351         else:
1352             self.__field_maxentries=UINT(value,**{'constant': 700})
1353 
1354     def __delfield_maxentries(self): del self.__field_maxentries
1355 
1356     maxentries=property(__getfield_maxentries, __setfield_maxentries, __delfield_maxentries, None)
1357 
1358     def __getfield_startcommand(self):
1359         return self.__field_startcommand.getvalue()
1360 
1361     def __setfield_startcommand(self, value):
1362         if isinstance(value,UINT):
1363             self.__field_startcommand=value
1364         else:
1365             self.__field_startcommand=UINT(value,**{'constant': 0x46})
1366 
1367     def __delfield_startcommand(self): del self.__field_startcommand
1368 
1369     startcommand=property(__getfield_startcommand, __setfield_startcommand, __delfield_startcommand, "Starting command for R/W buf parts")
1370 
1371     def __getfield_bufsize(self):
1372         return self.__field_bufsize.getvalue()
1373 
1374     def __setfield_bufsize(self, value):
1375         if isinstance(value,UINT):
1376             self.__field_bufsize=value
1377         else:
1378             self.__field_bufsize=UINT(value,**{'constant': 9216})
1379 
1380     def __delfield_bufsize(self): del self.__field_bufsize
1381 
1382     bufsize=property(__getfield_bufsize, __setfield_bufsize, __delfield_bufsize, None)
1383 
1384     def __getfield_comment(self):
1385         try: self.__field_comment
1386         except:
1387             self.__field_comment=USTRING(**{'default': "callerid"})
1388         return self.__field_comment.getvalue()
1389 
1390     def __setfield_comment(self, value):
1391         if isinstance(value,USTRING):
1392             self.__field_comment=value
1393         else:
1394             self.__field_comment=USTRING(value,**{'default': "callerid"})
1395 
1396     def __delfield_comment(self): del self.__field_comment
1397 
1398     comment=property(__getfield_comment, __setfield_comment, __delfield_comment, None)
1399 
1400     def __getfield_numentries(self):
1401         return self.__field_numentries.getvalue()
1402 
1403     def __setfield_numentries(self, value):
1404         if isinstance(value,UINT):
1405             self.__field_numentries=value
1406         else:
1407             self.__field_numentries=UINT(value,**{'sizeinbytes': 2})
1408 
1409     def __delfield_numentries(self): del self.__field_numentries
1410 
1411     numentries=property(__getfield_numentries, __setfield_numentries, __delfield_numentries, "Number phone numbers")
1412 
1413     def __getfield_items(self):
1414         try: self.__field_items
1415         except:
1416             self.__field_items=LIST(**{'length': self.maxentries, 'elementclass': calleridentry, 'createdefault': True})
1417         return self.__field_items.getvalue()
1418 
1419     def __setfield_items(self, value):
1420         if isinstance(value,LIST):
1421             self.__field_items=value
1422         else:
1423             self.__field_items=LIST(value,**{'length': self.maxentries, 'elementclass': calleridentry, 'createdefault': True})
1424 
1425     def __delfield_items(self): del self.__field_items
1426 
1427     items=property(__getfield_items, __setfield_items, __delfield_items, None)
1428 
1429     def __getfield_pad(self):
1430         try: self.__field_pad
1431         except:
1432             self.__field_pad=UNKNOWN()
1433         return self.__field_pad.getvalue()
1434 
1435     def __setfield_pad(self, value):
1436         if isinstance(value,UNKNOWN):
1437             self.__field_pad=value
1438         else:
1439             self.__field_pad=UNKNOWN(value,)
1440 
1441     def __delfield_pad(self): del self.__field_pad
1442 
1443     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
1444 
1445     def iscontainer(self):
1446         return True
1447 
1448     def containerelements(self):
1449         yield ('maxentries', self.__field_maxentries, None)
1450         yield ('startcommand', self.__field_startcommand, "Starting command for R/W buf parts")
1451         yield ('bufsize', self.__field_bufsize, None)
1452         yield ('comment', self.__field_comment, None)
1453         yield ('numentries', self.__field_numentries, "Number phone numbers")
1454         yield ('items', self.__field_items, None)
1455         yield ('pad', self.__field_pad, None)
1456 
1457 
1458 
1459 
1460 class evententry(BaseProtogenClass):
1461     __fields=['slot', 'eventname', 'pad1', 'eventname_len', 'start', 'end', 'location', 'pad2', 'location_len', 'alarmdiff', 'period', 'dom', 'alarm', 'pad3', 'serial', 'pad4', 'ringtone']
1462 
1463     def __init__(self, *args, **kwargs):
1464         dict={}
1465         # What was supplied to this function
1466         dict.update(kwargs)
1467         # Parent constructor
1468         super(evententry,self).__init__(**dict)
1469         if self.__class__ is evententry:
1470             self._update(args,dict)
1471 
1472 
1473     def getfields(self):
1474         return self.__fields
1475 
1476 
1477     def _update(self, args, kwargs):
1478         super(evententry,self)._update(args,kwargs)
1479         keys=kwargs.keys()
1480         for key in keys:
1481             if key in self.__fields:
1482                 setattr(self, key, kwargs[key])
1483                 del kwargs[key]
1484         # Were any unrecognized kwargs passed in?
1485         if __debug__:
1486             self._complainaboutunusedargs(evententry,kwargs)
1487         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1488         # Make all P fields that haven't already been constructed
1489 
1490 
1491     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1492         'Writes this packet to the supplied buffer'
1493         self._bufferstartoffset=buf.getcurrentoffset()
1494         self.__field_slot.writetobuffer(buf)
1495         self.__field_eventname.writetobuffer(buf)
1496         try: self.__field_pad1
1497         except:
1498             self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7})
1499         self.__field_pad1.writetobuffer(buf)
1500         self.__field_eventname_len.writetobuffer(buf)
1501         self.__field_start.writetobuffer(buf)
1502         self.__field_end.writetobuffer(buf)
1503         self.__field_location.writetobuffer(buf)
1504         try: self.__field_pad2
1505         except:
1506             self.__field_pad2=UNKNOWN(**{'sizeinbytes': 7})
1507         self.__field_pad2.writetobuffer(buf)
1508         self.__field_location_len.writetobuffer(buf)
1509         self.__field_alarmdiff.writetobuffer(buf)
1510         self.__field_period.writetobuffer(buf)
1511         self.__field_dom.writetobuffer(buf)
1512         self.__field_alarm.writetobuffer(buf)
1513         try: self.__field_pad3
1514         except:
1515             self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1})
1516         self.__field_pad3.writetobuffer(buf)
1517         try: self.__field_serial
1518         except:
1519             self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0})
1520         self.__field_serial.writetobuffer(buf)
1521         try: self.__field_pad4
1522         except:
1523             self.__field_pad4=UNKNOWN(**{'sizeinbytes': 3})
1524         self.__field_pad4.writetobuffer(buf)
1525         self.__field_ringtone.writetobuffer(buf)
1526         self._bufferendoffset=buf.getcurrentoffset()
1527         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1528 
1529 
1530     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1531         'Reads this packet from the supplied buffer'
1532         self._bufferstartoffset=buf.getcurrentoffset()
1533         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1534         self.__field_slot=UINT(**{'sizeinbytes': 1})
1535         self.__field_slot.readfrombuffer(buf)
1536         self.__field_eventname=USTRING(**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})
1537         self.__field_eventname.readfrombuffer(buf)
1538         self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7})
1539         self.__field_pad1.readfrombuffer(buf)
1540         self.__field_eventname_len=UINT(**{'sizeinbytes': 1})
1541         self.__field_eventname_len.readfrombuffer(buf)
1542         self.__field_start=UINT(**{'sizeinbytes': 4})
1543         self.__field_start.readfrombuffer(buf)
1544         self.__field_end=UINT(**{'sizeinbytes': 4})
1545         self.__field_end.readfrombuffer(buf)
1546         self.__field_location=USTRING(**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})
1547         self.__field_location.readfrombuffer(buf)
1548         self.__field_pad2=UNKNOWN(**{'sizeinbytes': 7})
1549         self.__field_pad2.readfrombuffer(buf)
1550         self.__field_location_len=UINT(**{'sizeinbytes': 1})
1551         self.__field_location_len.readfrombuffer(buf)
1552         self.__field_alarmdiff=UINT(**{'sizeinbytes': 4})
1553         self.__field_alarmdiff.readfrombuffer(buf)
1554         self.__field_period=UINT(**{'sizeinbytes': 1})
1555         self.__field_period.readfrombuffer(buf)
1556         self.__field_dom=UINT(**{'sizeinbytes': 1})
1557         self.__field_dom.readfrombuffer(buf)
1558         self.__field_alarm=UINT(**{'sizeinbytes': 4})
1559         self.__field_alarm.readfrombuffer(buf)
1560         self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1})
1561         self.__field_pad3.readfrombuffer(buf)
1562         self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0})
1563         self.__field_serial.readfrombuffer(buf)
1564         self.__field_pad4=UNKNOWN(**{'sizeinbytes': 3})
1565         self.__field_pad4.readfrombuffer(buf)
1566         self.__field_ringtone=UINT(**{'sizeinbytes': 2})
1567         self.__field_ringtone.readfrombuffer(buf)
1568         self._bufferendoffset=buf.getcurrentoffset()
1569 
1570 
1571     def __getfield_slot(self):
1572         return self.__field_slot.getvalue()
1573 
1574     def __setfield_slot(self, value):
1575         if isinstance(value,UINT):
1576             self.__field_slot=value
1577         else:
1578             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
1579 
1580     def __delfield_slot(self): del self.__field_slot
1581 
1582     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
1583 
1584     def __getfield_eventname(self):
1585         return self.__field_eventname.getvalue()
1586 
1587     def __setfield_eventname(self, value):
1588         if isinstance(value,USTRING):
1589             self.__field_eventname=value
1590         else:
1591             self.__field_eventname=USTRING(value,**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})
1592 
1593     def __delfield_eventname(self): del self.__field_eventname
1594 
1595     eventname=property(__getfield_eventname, __setfield_eventname, __delfield_eventname, None)
1596 
1597     def __getfield_pad1(self):
1598         try: self.__field_pad1
1599         except:
1600             self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7})
1601         return self.__field_pad1.getvalue()
1602 
1603     def __setfield_pad1(self, value):
1604         if isinstance(value,UNKNOWN):
1605             self.__field_pad1=value
1606         else:
1607             self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 7})
1608 
1609     def __delfield_pad1(self): del self.__field_pad1
1610 
1611     pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None)
1612 
1613     def __getfield_eventname_len(self):
1614         return self.__field_eventname_len.getvalue()
1615 
1616     def __setfield_eventname_len(self, value):
1617         if isinstance(value,UINT):
1618             self.__field_eventname_len=value
1619         else:
1620             self.__field_eventname_len=UINT(value,**{'sizeinbytes': 1})
1621 
1622     def __delfield_eventname_len(self): del self.__field_eventname_len
1623 
1624     eventname_len=property(__getfield_eventname_len, __setfield_eventname_len, __delfield_eventname_len, None)
1625 
1626     def __getfield_start(self):
1627         return self.__field_start.getvalue()
1628 
1629     def __setfield_start(self, value):
1630         if isinstance(value,UINT):
1631             self.__field_start=value
1632         else:
1633             self.__field_start=UINT(value,**{'sizeinbytes': 4})
1634 
1635     def __delfield_start(self): del self.__field_start
1636 
1637     start=property(__getfield_start, __setfield_start, __delfield_start, "# seconds since Jan 1, 1980 approximately")
1638 
1639     def __getfield_end(self):
1640         return self.__field_end.getvalue()
1641 
1642     def __setfield_end(self, value):
1643         if isinstance(value,UINT):
1644             self.__field_end=value
1645         else:
1646             self.__field_end=UINT(value,**{'sizeinbytes': 4})
1647 
1648     def __delfield_end(self): del self.__field_end
1649 
1650     end=property(__getfield_end, __setfield_end, __delfield_end, None)
1651 
1652     def __getfield_location(self):
1653         return self.__field_location.getvalue()
1654 
1655     def __setfield_location(self, value):
1656         if isinstance(value,USTRING):
1657             self.__field_location=value
1658         else:
1659             self.__field_location=USTRING(value,**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})
1660 
1661     def __delfield_location(self): del self.__field_location
1662 
1663     location=property(__getfield_location, __setfield_location, __delfield_location, None)
1664 
1665     def __getfield_pad2(self):
1666         try: self.__field_pad2
1667         except:
1668             self.__field_pad2=UNKNOWN(**{'sizeinbytes': 7})
1669         return self.__field_pad2.getvalue()
1670 
1671     def __setfield_pad2(self, value):
1672         if isinstance(value,UNKNOWN):
1673             self.__field_pad2=value
1674         else:
1675             self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 7})
1676 
1677     def __delfield_pad2(self): del self.__field_pad2
1678 
1679     pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None)
1680 
1681     def __getfield_location_len(self):
1682         return self.__field_location_len.getvalue()
1683 
1684     def __setfield_location_len(self, value):
1685         if isinstance(value,UINT):
1686             self.__field_location_len=value
1687         else:
1688             self.__field_location_len=UINT(value,**{'sizeinbytes': 1})
1689 
1690     def __delfield_location_len(self): del self.__field_location_len
1691 
1692     location_len=property(__getfield_location_len, __setfield_location_len, __delfield_location_len, None)
1693 
1694     def __getfield_alarmdiff(self):
1695         return self.__field_alarmdiff.getvalue()
1696 
1697     def __setfield_alarmdiff(self, value):
1698         if isinstance(value,UINT):
1699             self.__field_alarmdiff=value
1700         else:
1701             self.__field_alarmdiff=UINT(value,**{'sizeinbytes': 4})
1702 
1703     def __delfield_alarmdiff(self): del self.__field_alarmdiff
1704 
1705     alarmdiff=property(__getfield_alarmdiff, __setfield_alarmdiff, __delfield_alarmdiff, "Displayed alarm time")
1706 
1707     def __getfield_period(self):
1708         return self.__field_period.getvalue()
1709 
1710     def __setfield_period(self, value):
1711         if isinstance(value,UINT):
1712             self.__field_period=value
1713         else:
1714             self.__field_period=UINT(value,**{'sizeinbytes': 1})
1715 
1716     def __delfield_period(self): del self.__field_period
1717 
1718     period=property(__getfield_period, __setfield_period, __delfield_period, "No, Daily, Weekly, Monthly, Yearly")
1719 
1720     def __getfield_dom(self):
1721         return self.__field_dom.getvalue()
1722 
1723     def __setfield_dom(self, value):
1724         if isinstance(value,UINT):
1725             self.__field_dom=value
1726         else:
1727             self.__field_dom=UINT(value,**{'sizeinbytes': 1})
1728 
1729     def __delfield_dom(self): del self.__field_dom
1730 
1731     dom=property(__getfield_dom, __setfield_dom, __delfield_dom, "Day of month for the event")
1732 
1733     def __getfield_alarm(self):
1734         return self.__field_alarm.getvalue()
1735 
1736     def __setfield_alarm(self, value):
1737         if isinstance(value,UINT):
1738             self.__field_alarm=value
1739         else:
1740             self.__field_alarm=UINT(value,**{'sizeinbytes': 4})
1741 
1742     def __delfield_alarm(self): del self.__field_alarm
1743 
1744     alarm=property(__getfield_alarm, __setfield_alarm, __delfield_alarm, None)
1745 
1746     def __getfield_pad3(self):
1747         try: self.__field_pad3
1748         except:
1749             self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1})
1750         return self.__field_pad3.getvalue()
1751 
1752     def __setfield_pad3(self, value):
1753         if isinstance(value,UNKNOWN):
1754             self.__field_pad3=value
1755         else:
1756             self.__field_pad3=UNKNOWN(value,**{'sizeinbytes': 1})
1757 
1758     def __delfield_pad3(self): del self.__field_pad3
1759 
1760     pad3=property(__getfield_pad3, __setfield_pad3, __delfield_pad3, None)
1761 
1762     def __getfield_serial(self):
1763         try: self.__field_serial
1764         except:
1765             self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0})
1766         return self.__field_serial.getvalue()
1767 
1768     def __setfield_serial(self, value):
1769         if isinstance(value,UINT):
1770             self.__field_serial=value
1771         else:
1772             self.__field_serial=UINT(value,**{'sizeinbytes': 1, 'default': 0})
1773 
1774     def __delfield_serial(self): del self.__field_serial
1775 
1776     serial=property(__getfield_serial, __setfield_serial, __delfield_serial, "Some kind of serial number")
1777 
1778     def __getfield_pad4(self):
1779         try: self.__field_pad4
1780         except:
1781             self.__field_pad4=UNKNOWN(**{'sizeinbytes': 3})
1782         return self.__field_pad4.getvalue()
1783 
1784     def __setfield_pad4(self, value):
1785         if isinstance(value,UNKNOWN):
1786             self.__field_pad4=value
1787         else:
1788             self.__field_pad4=UNKNOWN(value,**{'sizeinbytes': 3})
1789 
1790     def __delfield_pad4(self): del self.__field_pad4
1791 
1792     pad4=property(__getfield_pad4, __setfield_pad4, __delfield_pad4, None)
1793 
1794     def __getfield_ringtone(self):
1795         return self.__field_ringtone.getvalue()
1796 
1797     def __setfield_ringtone(self, value):
1798         if isinstance(value,UINT):
1799             self.__field_ringtone=value
1800         else:
1801             self.__field_ringtone=UINT(value,**{'sizeinbytes': 2})
1802 
1803     def __delfield_ringtone(self): del self.__field_ringtone
1804 
1805     ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None)
1806 
1807     def iscontainer(self):
1808         return True
1809 
1810     def containerelements(self):
1811         yield ('slot', self.__field_slot, None)
1812         yield ('eventname', self.__field_eventname, None)
1813         yield ('pad1', self.__field_pad1, None)
1814         yield ('eventname_len', self.__field_eventname_len, None)
1815         yield ('start', self.__field_start, "# seconds since Jan 1, 1980 approximately")
1816         yield ('end', self.__field_end, None)
1817         yield ('location', self.__field_location, None)
1818         yield ('pad2', self.__field_pad2, None)
1819         yield ('location_len', self.__field_location_len, None)
1820         yield ('alarmdiff', self.__field_alarmdiff, "Displayed alarm time")
1821         yield ('period', self.__field_period, "No, Daily, Weekly, Monthly, Yearly")
1822         yield ('dom', self.__field_dom, "Day of month for the event")
1823         yield ('alarm', self.__field_alarm, None)
1824         yield ('pad3', self.__field_pad3, None)
1825         yield ('serial', self.__field_serial, "Some kind of serial number")
1826         yield ('pad4', self.__field_pad4, None)
1827         yield ('ringtone', self.__field_ringtone, None)
1828 
1829 
1830 
1831 
1832 class eventrequest(BaseProtogenClass):
1833     __fields=['header', 'slot', 'pad']
1834 
1835     def __init__(self, *args, **kwargs):
1836         dict={}
1837         # What was supplied to this function
1838         dict.update(kwargs)
1839         # Parent constructor
1840         super(eventrequest,self).__init__(**dict)
1841         if self.__class__ is eventrequest:
1842             self._update(args,dict)
1843 
1844 
1845     def getfields(self):
1846         return self.__fields
1847 
1848 
1849     def _update(self, args, kwargs):
1850         super(eventrequest,self)._update(args,kwargs)
1851         keys=kwargs.keys()
1852         for key in keys:
1853             if key in self.__fields:
1854                 setattr(self, key, kwargs[key])
1855                 del kwargs[key]
1856         # Were any unrecognized kwargs passed in?
1857         if __debug__:
1858             self._complainaboutunusedargs(eventrequest,kwargs)
1859         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1860         # Make all P fields that haven't already been constructed
1861 
1862 
1863     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1864         'Writes this packet to the supplied buffer'
1865         self._bufferstartoffset=buf.getcurrentoffset()
1866         try: self.__field_header
1867         except:
1868             self.__field_header=qcpheader(**{'packettype': 0x0c, 'command': 0x23})
1869         self.__field_header.writetobuffer(buf)
1870         self.__field_slot.writetobuffer(buf)
1871         try: self.__field_pad
1872         except:
1873             self.__field_pad=UNKNOWN(**{'sizeinbytes': 129})
1874         self.__field_pad.writetobuffer(buf)
1875         self._bufferendoffset=buf.getcurrentoffset()
1876         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1877 
1878 
1879     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1880         'Reads this packet from the supplied buffer'
1881         self._bufferstartoffset=buf.getcurrentoffset()
1882         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1883         self.__field_header=qcpheader(**{'packettype': 0x0c, 'command': 0x23})
1884         self.__field_header.readfrombuffer(buf)
1885         self.__field_slot=UINT(**{'sizeinbytes': 1})
1886         self.__field_slot.readfrombuffer(buf)
1887         self.__field_pad=UNKNOWN(**{'sizeinbytes': 129})
1888         self.__field_pad.readfrombuffer(buf)
1889         self._bufferendoffset=buf.getcurrentoffset()
1890 
1891 
1892     def __getfield_header(self):
1893         try: self.__field_header
1894         except:
1895             self.__field_header=qcpheader(**{'packettype': 0x0c, 'command': 0x23})
1896         return self.__field_header.getvalue()
1897 
1898     def __setfield_header(self, value):
1899         if isinstance(value,qcpheader):
1900             self.__field_header=value
1901         else:
1902             self.__field_header=qcpheader(value,**{'packettype': 0x0c, 'command': 0x23})
1903 
1904     def __delfield_header(self): del self.__field_header
1905 
1906     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1907 
1908     def __getfield_slot(self):
1909         return self.__field_slot.getvalue()
1910 
1911     def __setfield_slot(self, value):
1912         if isinstance(value,UINT):
1913             self.__field_slot=value
1914         else:
1915             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
1916 
1917     def __delfield_slot(self): del self.__field_slot
1918 
1919     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
1920 
1921     def __getfield_pad(self):
1922         try: self.__field_pad
1923         except:
1924             self.__field_pad=UNKNOWN(**{'sizeinbytes': 129})
1925         return self.__field_pad.getvalue()
1926 
1927     def __setfield_pad(self, value):
1928         if isinstance(value,UNKNOWN):
1929             self.__field_pad=value
1930         else:
1931             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 129})
1932 
1933     def __delfield_pad(self): del self.__field_pad
1934 
1935     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
1936 
1937     def iscontainer(self):
1938         return True
1939 
1940     def containerelements(self):
1941         yield ('header', self.__field_header, None)
1942         yield ('slot', self.__field_slot, None)
1943         yield ('pad', self.__field_pad, None)
1944 
1945 
1946 
1947 
1948 class eventresponse(BaseProtogenClass):
1949     __fields=['header', 'entry', 'pad']
1950 
1951     def __init__(self, *args, **kwargs):
1952         dict={}
1953         # What was supplied to this function
1954         dict.update(kwargs)
1955         # Parent constructor
1956         super(eventresponse,self).__init__(**dict)
1957         if self.__class__ is eventresponse:
1958             self._update(args,dict)
1959 
1960 
1961     def getfields(self):
1962         return self.__fields
1963 
1964 
1965     def _update(self, args, kwargs):
1966         super(eventresponse,self)._update(args,kwargs)
1967         keys=kwargs.keys()
1968         for key in keys:
1969             if key in self.__fields:
1970                 setattr(self, key, kwargs[key])
1971                 del kwargs[key]
1972         # Were any unrecognized kwargs passed in?
1973         if __debug__:
1974             self._complainaboutunusedargs(eventresponse,kwargs)
1975         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1976         # Make all P fields that haven't already been constructed
1977 
1978 
1979     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1980         'Writes this packet to the supplied buffer'
1981         self._bufferstartoffset=buf.getcurrentoffset()
1982         self.__field_header.writetobuffer(buf)
1983         self.__field_entry.writetobuffer(buf)
1984         self.__field_pad.writetobuffer(buf)
1985         self._bufferendoffset=buf.getcurrentoffset()
1986         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1987 
1988 
1989     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1990         'Reads this packet from the supplied buffer'
1991         self._bufferstartoffset=buf.getcurrentoffset()
1992         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1993         self.__field_header=qcpheader()
1994         self.__field_header.readfrombuffer(buf)
1995         self.__field_entry=evententry()
1996         self.__field_entry.readfrombuffer(buf)
1997         self.__field_pad=UNKNOWN()
1998         self.__field_pad.readfrombuffer(buf)
1999         self._bufferendoffset=buf.getcurrentoffset()
2000 
2001 
2002     def __getfield_header(self):
2003         return self.__field_header.getvalue()
2004 
2005     def __setfield_header(self, value):
2006         if isinstance(value,qcpheader):
2007             self.__field_header=value
2008         else:
2009             self.__field_header=qcpheader(value,)
2010 
2011     def __delfield_header(self): del self.__field_header
2012 
2013     header=property(__getfield_header, __setfield_header, __delfield_header, None)
2014 
2015     def __getfield_entry(self):
2016         return self.__field_entry.getvalue()
2017 
2018     def __setfield_entry(self, value):
2019         if isinstance(value,evententry):
2020             self.__field_entry=value
2021         else:
2022             self.__field_entry=evententry(value,)
2023 
2024     def __delfield_entry(self): del self.__field_entry
2025 
2026     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
2027 
2028     def __getfield_pad(self):
2029         return self.__field_pad.getvalue()
2030 
2031     def __setfield_pad(self, value):
2032         if isinstance(value,UNKNOWN):
2033             self.__field_pad=value
2034         else:
2035             self.__field_pad=UNKNOWN(value,)
2036 
2037     def __delfield_pad(self): del self.__field_pad
2038 
2039     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
2040 
2041     def iscontainer(self):
2042         return True
2043 
2044     def containerelements(self):
2045         yield ('header', self.__field_header, None)
2046         yield ('entry', self.__field_entry, None)
2047         yield ('pad', self.__field_pad, None)
2048 
2049 
2050 
2051 
2052 class eventslotinuserequest(BaseProtogenClass):
2053     __fields=['header', 'slot', 'pad']
2054 
2055     def __init__(self, *args, **kwargs):
2056         dict={}
2057         # What was supplied to this function
2058         dict.update(kwargs)
2059         # Parent constructor
2060         super(eventslotinuserequest,self).__init__(**dict)
2061         if self.__class__ is eventslotinuserequest:
2062             self._update(args,dict)
2063 
2064 
2065     def getfields(self):
2066         return self.__fields
2067 
2068 
2069     def _update(self, args, kwargs):
2070         super(eventslotinuserequest,self)._update(args,kwargs)
2071         keys=kwargs.keys()
2072         for key in keys:
2073             if key in self.__fields:
2074                 setattr(self, key, kwargs[key])
2075                 del kwargs[key]
2076         # Were any unrecognized kwargs passed in?
2077         if __debug__:
2078             self._complainaboutunusedargs(eventslotinuserequest,kwargs)
2079         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2080         # Make all P fields that haven't already been constructed
2081 
2082 
2083     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2084         'Writes this packet to the supplied buffer'
2085         self._bufferstartoffset=buf.getcurrentoffset()
2086         try: self.__field_header
2087         except:
2088             self.__field_header=qcpheader(**{'readwrite': 0x26, 'packettype': 0x0d, 'command': 0x74})
2089         self.__field_header.writetobuffer(buf)
2090         self.__field_slot.writetobuffer(buf)
2091         try: self.__field_pad
2092         except:
2093             self.__field_pad=UNKNOWN(**{'sizeinbytes': 129})
2094         self.__field_pad.writetobuffer(buf)
2095         self._bufferendoffset=buf.getcurrentoffset()
2096         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2097 
2098 
2099     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2100         'Reads this packet from the supplied buffer'
2101         self._bufferstartoffset=buf.getcurrentoffset()
2102         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2103         self.__field_header=qcpheader(**{'readwrite': 0x26, 'packettype': 0x0d, 'command': 0x74})
2104         self.__field_header.readfrombuffer(buf)
2105         self.__field_slot=UINT(**{'sizeinbytes': 1})
2106         self.__field_slot.readfrombuffer(buf)
2107         self.__field_pad=UNKNOWN(**{'sizeinbytes': 129})
2108         self.__field_pad.readfrombuffer(buf)
2109         self._bufferendoffset=buf.getcurrentoffset()
2110 
2111 
2112     def __getfield_header(self):
2113         try: self.__field_header
2114         except:
2115             self.__field_header=qcpheader(**{'readwrite': 0x26, 'packettype': 0x0d, 'command': 0x74})
2116         return self.__field_header.getvalue()
2117 
2118     def __setfield_header(self, value):
2119         if isinstance(value,qcpheader):
2120             self.__field_header=value
2121         else:
2122             self.__field_header=qcpheader(value,**{'readwrite': 0x26, 'packettype': 0x0d, 'command': 0x74})
2123 
2124     def __delfield_header(self): del self.__field_header
2125 
2126     header=property(__getfield_header, __setfield_header, __delfield_header, None)
2127 
2128     def __getfield_slot(self):
2129         return self.__field_slot.getvalue()
2130 
2131     def __setfield_slot(self, value):
2132         if isinstance(value,UINT):
2133             self.__field_slot=value
2134         else:
2135             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
2136 
2137     def __delfield_slot(self): del self.__field_slot
2138 
2139     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
2140 
2141     def __getfield_pad(self):
2142         try: self.__field_pad
2143         except:
2144             self.__field_pad=UNKNOWN(**{'sizeinbytes': 129})
2145         return self.__field_pad.getvalue()
2146 
2147     def __setfield_pad(self, value):
2148         if isinstance(value,UNKNOWN):
2149             self.__field_pad=value
2150         else:
2151             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 129})
2152 
2153     def __delfield_pad(self): del self.__field_pad
2154 
2155     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
2156 
2157     def iscontainer(self):
2158         return True
2159 
2160     def containerelements(self):
2161         yield ('header', self.__field_header, None)
2162         yield ('slot', self.__field_slot, None)
2163         yield ('pad', self.__field_pad, None)
2164 
2165 
2166 
2167 
2168 class eventslotinuseresponse(BaseProtogenClass):
2169     __fields=['header', 'slot', 'flag', 'pad']
2170 
2171     def __init__(self, *args, **kwargs):
2172         dict={}
2173         # What was supplied to this function
2174         dict.update(kwargs)
2175         # Parent constructor
2176         super(eventslotinuseresponse,self).__init__(**dict)
2177         if self.__class__ is eventslotinuseresponse:
2178             self._update(args,dict)
2179 
2180 
2181     def getfields(self):
2182         return self.__fields
2183 
2184 
2185     def _update(self, args, kwargs):
2186         super(eventslotinuseresponse,self)._update(args,kwargs)
2187         keys=kwargs.keys()
2188         for key in keys:
2189             if key in self.__fields:
2190                 setattr(self, key, kwargs[key])
2191                 del kwargs[key]
2192         # Were any unrecognized kwargs passed in?
2193         if __debug__:
2194             self._complainaboutunusedargs(eventslotinuseresponse,kwargs)
2195         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2196         # Make all P fields that haven't already been constructed
2197 
2198 
2199     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2200         'Writes this packet to the supplied buffer'
2201         self._bufferstartoffset=buf.getcurrentoffset()
2202         self.__field_header.writetobuffer(buf)
2203         self.__field_slot.writetobuffer(buf)
2204         self.__field_flag.writetobuffer(buf)
2205         self.__field_pad.writetobuffer(buf)
2206         self._bufferendoffset=buf.getcurrentoffset()
2207         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2208 
2209 
2210     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2211         'Reads this packet from the supplied buffer'
2212         self._bufferstartoffset=buf.getcurrentoffset()
2213         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2214         self.__field_header=qcpheader()
2215         self.__field_header.readfrombuffer(buf)
2216         self.__field_slot=UINT(**{'sizeinbytes': 1})
2217         self.__field_slot.readfrombuffer(buf)
2218         self.__field_flag=UINT(**{'sizeinbytes': 1})
2219         self.__field_flag.readfrombuffer(buf)
2220         self.__field_pad=UNKNOWN()
2221         self.__field_pad.readfrombuffer(buf)
2222         self._bufferendoffset=buf.getcurrentoffset()
2223 
2224 
2225     def __getfield_header(self):
2226         return self.__field_header.getvalue()
2227 
2228     def __setfield_header(self, value):
2229         if isinstance(value,qcpheader):
2230             self.__field_header=value
2231         else:
2232             self.__field_header=qcpheader(value,)
2233 
2234     def __delfield_header(self): del self.__field_header
2235 
2236     header=property(__getfield_header, __setfield_header, __delfield_header, None)
2237 
2238     def __getfield_slot(self):
2239         return self.__field_slot.getvalue()
2240 
2241     def __setfield_slot(self, value):
2242         if isinstance(value,UINT):
2243             self.__field_slot=value
2244         else:
2245             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
2246 
2247     def __delfield_slot(self): del self.__field_slot
2248 
2249     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
2250 
2251     def __getfield_flag(self):
2252         return self.__field_flag.getvalue()
2253 
2254     def __setfield_flag(self, value):
2255         if isinstance(value,UINT):
2256             self.__field_flag=value
2257         else:
2258             self.__field_flag=UINT(value,**{'sizeinbytes': 1})
2259 
2260     def __delfield_flag(self): del self.__field_flag
2261 
2262     flag=property(__getfield_flag, __setfield_flag, __delfield_flag, None)
2263 
2264     def __getfield_pad(self):
2265         return self.__field_pad.getvalue()
2266 
2267     def __setfield_pad(self, value):
2268         if isinstance(value,UNKNOWN):
2269             self.__field_pad=value
2270         else:
2271             self.__field_pad=UNKNOWN(value,)
2272 
2273     def __delfield_pad(self): del self.__field_pad
2274 
2275     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
2276 
2277     def iscontainer(self):
2278         return True
2279 
2280     def containerelements(self):
2281         yield ('header', self.__field_header, None)
2282         yield ('slot', self.__field_slot, None)
2283         yield ('flag', self.__field_flag, None)
2284         yield ('pad', self.__field_pad, None)
2285 
2286 
2287 
2288 
2289 class eventslotinuseupdaterequest(BaseProtogenClass):
2290     __fields=['header', 'slot', 'flag', 'pad']
2291 
2292     def __init__(self, *args, **kwargs):
2293         dict={}
2294         # What was supplied to this function
2295         dict.update(kwargs)
2296         # Parent constructor
2297         super(eventslotinuseupdaterequest,self).__init__(**dict)
2298         if self.__class__ is eventslotinuseupdaterequest:
2299             self._update(args,dict)
2300 
2301 
2302     def getfields(self):
2303         return self.__fields
2304 
2305 
2306     def _update(self, args, kwargs):
2307         super(eventslotinuseupdaterequest,self)._update(args,kwargs)
2308         keys=kwargs.keys()
2309         for key in keys:
2310             if key in self.__fields:
2311                 setattr(self, key, kwargs[key])
2312                 del kwargs[key]
2313         # Were any unrecognized kwargs passed in?
2314         if __debug__:
2315             self._complainaboutunusedargs(eventslotinuseupdaterequest,kwargs)
2316         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2317         # Make all P fields that haven't already been constructed
2318 
2319 
2320     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2321         'Writes this packet to the supplied buffer'
2322         self._bufferstartoffset=buf.getcurrentoffset()
2323         try: self.__field_header
2324         except:
2325             self.__field_header=qcpwriteheader(**{'packettype': 0x0d, 'command': 0x74})
2326         self.__field_header.writetobuffer(buf)
2327         self.__field_slot.writetobuffer(buf)
2328         self.__field_flag.writetobuffer(buf)
2329         try: self.__field_pad
2330         except:
2331             self.__field_pad=UNKNOWN(**{'sizeinbytes': 124})
2332         self.__field_pad.writetobuffer(buf)
2333         self._bufferendoffset=buf.getcurrentoffset()
2334         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2335 
2336 
2337     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2338         'Reads this packet from the supplied buffer'
2339         self._bufferstartoffset=buf.getcurrentoffset()
2340         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2341         self.__field_header=qcpwriteheader(**{'packettype': 0x0d, 'command': 0x74})
2342         self.__field_header.readfrombuffer(buf)
2343         self.__field_slot=UINT(**{'sizeinbytes': 1})
2344         self.__field_slot.readfrombuffer(buf)
2345         self.__field_flag=UINT(**{'sizeinbytes': 1})
2346         self.__field_flag.readfrombuffer(buf)
2347         self.__field_pad=UNKNOWN(**{'sizeinbytes': 124})
2348         self.__field_pad.readfrombuffer(buf)
2349         self._bufferendoffset=buf.getcurrentoffset()
2350 
2351 
2352     def __getfield_header(self):
2353         try: self.__field_header
2354         except:
2355             self.__field_header=qcpwriteheader(**{'packettype': 0x0d, 'command': 0x74})
2356         return self.__field_header.getvalue()
2357 
2358     def __setfield_header(self, value):
2359         if isinstance(value,qcpwriteheader):
2360             self.__field_header=value
2361         else:
2362             self.__field_header=qcpwriteheader(value,**{'packettype': 0x0d, 'command': 0x74})
2363 
2364     def __delfield_header(self): del self.__field_header
2365 
2366     header=property(__getfield_header, __setfield_header, __delfield_header, None)
2367 
2368     def __getfield_slot(self):
2369         return self.__field_slot.getvalue()
2370 
2371     def __setfield_slot(self, value):
2372         if isinstance(value,UINT):
2373             self.__field_slot=value
2374         else:
2375             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
2376 
2377     def __delfield_slot(self): del self.__field_slot
2378 
2379     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
2380 
2381     def __getfield_flag(self):
2382         return self.__field_flag.getvalue()
2383 
2384     def __setfield_flag(self, value):
2385         if isinstance(value,UINT):
2386             self.__field_flag=value
2387         else:
2388             self.__field_flag=UINT(value,**{'sizeinbytes': 1})
2389 
2390     def __delfield_flag(self): del self.__field_flag
2391 
2392     flag=property(__getfield_flag, __setfield_flag, __delfield_flag, None)
2393 
2394     def __getfield_pad(self):
2395         try: self.__field_pad
2396         except:
2397             self.__field_pad=UNKNOWN(**{'sizeinbytes': 124})
2398         return self.__field_pad.getvalue()
2399 
2400     def __setfield_pad(self, value):
2401         if isinstance(value,UNKNOWN):
2402             self.__field_pad=value
2403         else:
2404             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 124})
2405 
2406     def __delfield_pad(self): del self.__field_pad
2407 
2408     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
2409 
2410     def iscontainer(self):
2411         return True
2412 
2413     def containerelements(self):
2414         yield ('header', self.__field_header, None)
2415         yield ('slot', self.__field_slot, None)
2416         yield ('flag', self.__field_flag, None)
2417         yield ('pad', self.__field_pad, None)
2418 
2419 
2420 
2421 
2422 class eventupdaterequest(BaseProtogenClass):
2423     __fields=['header', 'entry', 'pad']
2424 
2425     def __init__(self, *args, **kwargs):
2426         dict={}
2427         # What was supplied to this function
2428         dict.update(kwargs)
2429         # Parent constructor
2430         super(eventupdaterequest,self).__init__(**dict)
2431         if self.__class__ is eventupdaterequest:
2432             self._update(args,dict)
2433 
2434 
2435     def getfields(self):
2436         return self.__fields
2437 
2438 
2439     def _update(self, args, kwargs):
2440         super(eventupdaterequest,self)._update(args,kwargs)
2441         keys=kwargs.keys()
2442         for key in keys:
2443             if key in self.__fields:
2444                 setattr(self, key, kwargs[key])
2445                 del kwargs[key]
2446         # Were any unrecognized kwargs passed in?
2447         if __debug__:
2448             self._complainaboutunusedargs(eventupdaterequest,kwargs)
2449         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2450         # Make all P fields that haven't already been constructed
2451 
2452 
2453     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2454         'Writes this packet to the supplied buffer'
2455         self._bufferstartoffset=buf.getcurrentoffset()
2456         try: self.__field_header
2457         except:
2458             self.__field_header=qcpwriteheader(**{'packettype': 0x0c, 'command':0x23})
2459         self.__field_header.writetobuffer(buf)
2460         self.__field_entry.writetobuffer(buf)
2461         try: self.__field_pad
2462         except:
2463             self.__field_pad=UNKNOWN(**{'sizeinbytes': 56})
2464         self.__field_pad.writetobuffer(buf)
2465         self._bufferendoffset=buf.getcurrentoffset()
2466         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2467 
2468 
2469     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2470         'Reads this packet from the supplied buffer'
2471         self._bufferstartoffset=buf.getcurrentoffset()
2472         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2473         self.__field_header=qcpwriteheader(**{'packettype': 0x0c, 'command':0x23})
2474         self.__field_header.readfrombuffer(buf)
2475         self.__field_entry=evententry()
2476         self.__field_entry.readfrombuffer(buf)
2477         self.__field_pad=UNKNOWN(**{'sizeinbytes': 56})
2478         self.__field_pad.readfrombuffer(buf)
2479         self._bufferendoffset=buf.getcurrentoffset()
2480 
2481 
2482     def __getfield_header(self):
2483         try: self.__field_header
2484         except:
2485             self.__field_header=qcpwriteheader(**{'packettype': 0x0c, 'command':0x23})
2486         return self.__field_header.getvalue()
2487 
2488     def __setfield_header(self, value):
2489         if isinstance(value,qcpwriteheader):
2490             self.__field_header=value
2491         else:
2492             self.__field_header=qcpwriteheader(value,**{'packettype': 0x0c, 'command':0x23})
2493 
2494     def __delfield_header(self): del self.__field_header
2495 
2496     header=property(__getfield_header, __setfield_header, __delfield_header, None)
2497 
2498     def __getfield_entry(self):
2499         return self.__field_entry.getvalue()
2500 
2501     def __setfield_entry(self, value):
2502         if isinstance(value,evententry):
2503             self.__field_entry=value
2504         else:
2505             self.__field_entry=evententry(value,)
2506 
2507     def __delfield_entry(self): del self.__field_entry
2508 
2509     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
2510 
2511     def __getfield_pad(self):
2512         try: self.__field_pad
2513         except:
2514             self.__field_pad=UNKNOWN(**{'sizeinbytes': 56})
2515         return self.__field_pad.getvalue()
2516 
2517     def __setfield_pad(self, value):
2518         if isinstance(value,UNKNOWN):
2519             self.__field_pad=value
2520         else:
2521             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 56})
2522 
2523     def __delfield_pad(self): del self.__field_pad
2524 
2525     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
2526 
2527     def iscontainer(self):
2528         return True
2529 
2530     def containerelements(self):
2531         yield ('header', self.__field_header, None)
2532         yield ('entry', self.__field_entry, None)
2533         yield ('pad', self.__field_pad, None)
2534 
2535 
2536 
2537 
2538 class callalarmrequest(BaseProtogenClass):
2539     __fields=['header', 'slot', 'pad']
2540 
2541     def __init__(self, *args, **kwargs):
2542         dict={}
2543         # What was supplied to this function
2544         dict.update(kwargs)
2545         # Parent constructor
2546         super(callalarmrequest,self).__init__(**dict)
2547         if self.__class__ is callalarmrequest:
2548             self._update(args,dict)
2549 
2550 
2551     def getfields(self):
2552         return self.__fields
2553 
2554 
2555     def _update(self, args, kwargs):
2556         super(callalarmrequest,self)._update(args,kwargs)
2557         keys=kwargs.keys()
2558         for key in keys:
2559             if key in self.__fields:
2560                 setattr(self, key, kwargs[key])
2561                 del kwargs[key]
2562         # Were any unrecognized kwargs passed in?
2563         if __debug__:
2564             self._complainaboutunusedargs(callalarmrequest,kwargs)
2565         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2566         # Make all P fields that haven't already been constructed
2567 
2568 
2569     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2570         'Writes this packet to the supplied buffer'
2571         self._bufferstartoffset=buf.getcurrentoffset()
2572         try: self.__field_header
2573         except:
2574             self.__field_header=qcpheader(**{'packettype': 0x0c, 'command': 0x24})
2575         self.__field_header.writetobuffer(buf)
2576         self.__field_slot.writetobuffer(buf)
2577         try: self.__field_pad
2578         except:
2579             self.__field_pad=UNKNOWN(**{'sizeinbytes': 129})
2580         self.__field_pad.writetobuffer(buf)
2581         self._bufferendoffset=buf.getcurrentoffset()
2582         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2583 
2584 
2585     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2586         'Reads this packet from the supplied buffer'
2587         self._bufferstartoffset=buf.getcurrentoffset()
2588         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2589         self.__field_header=qcpheader(**{'packettype': 0x0c, 'command': 0x24})
2590         self.__field_header.readfrombuffer(buf)
2591         self.__field_slot=UINT(**{'sizeinbytes': 1})
2592         self.__field_slot.readfrombuffer(buf)
2593         self.__field_pad=UNKNOWN(**{'sizeinbytes': 129})
2594         self.__field_pad.readfrombuffer(buf)
2595         self._bufferendoffset=buf.getcurrentoffset()
2596 
2597 
2598     def __getfield_header(self):
2599         try: self.__field_header
2600         except:
2601             self.__field_header=qcpheader(**{'packettype': 0x0c, 'command': 0x24})
2602         return self.__field_header.getvalue()
2603 
2604     def __setfield_header(self, value):
2605         if isinstance(value,qcpheader):
2606             self.__field_header=value
2607         else:
2608             self.__field_header=qcpheader(value,**{'packettype': 0x0c, 'command': 0x24})
2609 
2610     def __delfield_header(self): del self.__field_header
2611 
2612     header=property(__getfield_header, __setfield_header, __delfield_header, None)
2613 
2614     def __getfield_slot(self):
2615         return self.__field_slot.getvalue()
2616 
2617     def __setfield_slot(self, value):
2618         if isinstance(value,UINT):
2619             self.__field_slot=value
2620         else:
2621             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
2622 
2623     def __delfield_slot(self): del self.__field_slot
2624 
2625     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
2626 
2627     def __getfield_pad(self):
2628         try: self.__field_pad
2629         except:
2630             self.__field_pad=UNKNOWN(**{'sizeinbytes': 129})
2631         return self.__field_pad.getvalue()
2632 
2633     def __setfield_pad(self, value):
2634         if isinstance(value,UNKNOWN):
2635             self.__field_pad=value
2636         else:
2637             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 129})
2638 
2639     def __delfield_pad(self): del self.__field_pad
2640 
2641     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
2642 
2643     def iscontainer(self):
2644         return True
2645 
2646     def containerelements(self):
2647         yield ('header', self.__field_header, None)
2648         yield ('slot', self.__field_slot, None)
2649         yield ('pad', self.__field_pad, None)
2650 
2651 
2652 
2653 
2654 class callalarmresponse(BaseProtogenClass):
2655     __fields=['header', 'entry', 'pad']
2656 
2657     def __init__(self, *args, **kwargs):
2658         dict={}
2659         # What was supplied to this function
2660         dict.update(kwargs)
2661         # Parent constructor
2662         super(callalarmresponse,self).__init__(**dict)
2663         if self.__class__ is callalarmresponse:
2664             self._update(args,dict)
2665 
2666 
2667     def getfields(self):
2668         return self.__fields
2669 
2670 
2671     def _update(self, args, kwargs):
2672         super(callalarmresponse,self)._update(args,kwargs)
2673         keys=kwargs.keys()
2674         for key in keys:
2675             if key in self.__fields:
2676                 setattr(self, key, kwargs[key])
2677                 del kwargs[key]
2678         # Were any unrecognized kwargs passed in?
2679         if __debug__:
2680             self._complainaboutunusedargs(callalarmresponse,kwargs)
2681         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2682         # Make all P fields that haven't already been constructed
2683 
2684 
2685     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2686         'Writes this packet to the supplied buffer'
2687         self._bufferstartoffset=buf.getcurrentoffset()
2688         self.__field_header.writetobuffer(buf)
2689         self.__field_entry.writetobuffer(buf)
2690         self.__field_pad.writetobuffer(buf)
2691         self._bufferendoffset=buf.getcurrentoffset()
2692         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2693 
2694 
2695     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2696         'Reads this packet from the supplied buffer'
2697         self._bufferstartoffset=buf.getcurrentoffset()
2698         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2699         self.__field_header=qcpheader()
2700         self.__field_header.readfrombuffer(buf)
2701         self.__field_entry=callalarmentry()
2702         self.__field_entry.readfrombuffer(buf)
2703         self.__field_pad=UNKNOWN()
2704         self.__field_pad.readfrombuffer(buf)
2705         self._bufferendoffset=buf.getcurrentoffset()
2706 
2707 
2708     def __getfield_header(self):
2709         return self.__field_header.getvalue()
2710 
2711     def __setfield_header(self, value):
2712         if isinstance(value,qcpheader):
2713             self.__field_header=value
2714         else:
2715             self.__field_header=qcpheader(value,)
2716 
2717     def __delfield_header(self): del self.__field_header
2718 
2719     header=property(__getfield_header, __setfield_header, __delfield_header, None)
2720 
2721     def __getfield_entry(self):
2722         return self.__field_entry.getvalue()
2723 
2724     def __setfield_entry(self, value):
2725         if isinstance(value,callalarmentry):
2726             self.__field_entry=value
2727         else:
2728             self.__field_entry=callalarmentry(value,)
2729 
2730     def __delfield_entry(self): del self.__field_entry
2731 
2732     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
2733 
2734     def __getfield_pad(self):
2735         return self.__field_pad.getvalue()
2736 
2737     def __setfield_pad(self, value):
2738         if isinstance(value,UNKNOWN):
2739             self.__field_pad=value
2740         else:
2741             self.__field_pad=UNKNOWN(value,)
2742 
2743     def __delfield_pad(self): del self.__field_pad
2744 
2745     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
2746 
2747     def iscontainer(self):
2748         return True
2749 
2750     def containerelements(self):
2751         yield ('header', self.__field_header, None)
2752         yield ('entry', self.__field_entry, None)
2753         yield ('pad', self.__field_pad, None)
2754 
2755 
2756 
2757 
2758 class callalarmupdaterequest(BaseProtogenClass):
2759     __fields=['header', 'entry', 'pad']
2760 
2761     def __init__(self, *args, **kwargs):
2762         dict={}
2763         # What was supplied to this function
2764         dict.update(kwargs)
2765         # Parent constructor
2766         super(callalarmupdaterequest,self).__init__(**dict)
2767         if self.__class__ is callalarmupdaterequest:
2768             self._update(args,dict)
2769 
2770 
2771     def getfields(self):
2772         return self.__fields
2773 
2774 
2775     def _update(self, args, kwargs):
2776         super(callalarmupdaterequest,self)._update(args,kwargs)
2777         keys=kwargs.keys()
2778         for key in keys:
2779             if key in self.__fields:
2780                 setattr(self, key, kwargs[key])
2781                 del kwargs[key]
2782         # Were any unrecognized kwargs passed in?
2783         if __debug__:
2784             self._complainaboutunusedargs(callalarmupdaterequest,kwargs)
2785         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2786         # Make all P fields that haven't already been constructed
2787 
2788 
2789     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2790         'Writes this packet to the supplied buffer'
2791         self._bufferstartoffset=buf.getcurrentoffset()
2792         try: self.__field_header
2793         except:
2794             self.__field_header=qcpwriteheader(**{'packettype': 0x0c, 'command':0x24})
2795         self.__field_header.writetobuffer(buf)
2796         self.__field_entry.writetobuffer(buf)
2797         try: self.__field_pad
2798         except:
2799             self.__field_pad=UNKNOWN(**{'sizeinbytes': 40})
2800         self.__field_pad.writetobuffer(buf)
2801         self._bufferendoffset=buf.getcurrentoffset()
2802         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2803 
2804 
2805     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2806         'Reads this packet from the supplied buffer'
2807         self._bufferstartoffset=buf.getcurrentoffset()
2808         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2809         self.__field_header=qcpwriteheader(**{'packettype': 0x0c, 'command':0x24})
2810         self.__field_header.readfrombuffer(buf)
2811         self.__field_entry=callalarmentry()
2812         self.__field_entry.readfrombuffer(buf)
2813         self.__field_pad=UNKNOWN(**{'sizeinbytes': 40})
2814         self.__field_pad.readfrombuffer(buf)
2815         self._bufferendoffset=buf.getcurrentoffset()
2816 
2817 
2818     def __getfield_header(self):
2819         try: self.__field_header
2820         except:
2821             self.__field_header=qcpwriteheader(**{'packettype': 0x0c, 'command':0x24})
2822         return self.__field_header.getvalue()
2823 
2824     def __setfield_header(self, value):
2825         if isinstance(value,qcpwriteheader):
2826             self.__field_header=value
2827         else:
2828             self.__field_header=qcpwriteheader(value,**{'packettype': 0x0c, 'command':0x24})
2829 
2830     def __delfield_header(self): del self.__field_header
2831 
2832     header=property(__getfield_header, __setfield_header, __delfield_header, None)
2833 
2834     def __getfield_entry(self):
2835         return self.__field_entry.getvalue()
2836 
2837     def __setfield_entry(self, value):
2838         if isinstance(value,callalarmentry):
2839             self.__field_entry=value
2840         else:
2841             self.__field_entry=callalarmentry(value,)
2842 
2843     def __delfield_entry(self): del self.__field_entry
2844 
2845     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
2846 
2847     def __getfield_pad(self):
2848         try: self.__field_pad
2849         except:
2850             self.__field_pad=UNKNOWN(**{'sizeinbytes': 40})
2851         return self.__field_pad.getvalue()
2852 
2853     def __setfield_pad(self, value):
2854         if isinstance(value,UNKNOWN):
2855             self.__field_pad=value
2856         else:
2857             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 40})
2858 
2859     def __delfield_pad(self): del self.__field_pad
2860 
2861     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
2862 
2863     def iscontainer(self):
2864         return True
2865 
2866     def containerelements(self):
2867         yield ('header', self.__field_header, None)
2868         yield ('entry', self.__field_entry, None)
2869         yield ('pad', self.__field_pad, None)
2870 
2871 
2872 
2873 
2874 class callalarmslotinuserequest(BaseProtogenClass):
2875     __fields=['header', 'slot', 'pad']
2876 
2877     def __init__(self, *args, **kwargs):
2878         dict={}
2879         # What was supplied to this function
2880         dict.update(kwargs)
2881         # Parent constructor
2882         super(callalarmslotinuserequest,self).__init__(**dict)
2883         if self.__class__ is callalarmslotinuserequest:
2884             self._update(args,dict)
2885 
2886 
2887     def getfields(self):
2888         return self.__fields
2889 
2890 
2891     def _update(self, args, kwargs):
2892         super(callalarmslotinuserequest,self)._update(args,kwargs)
2893         keys=kwargs.keys()
2894         for key in keys:
2895             if key in self.__fields:
2896                 setattr(self, key, kwargs[key])
2897                 del kwargs[key]
2898         # Were any unrecognized kwargs passed in?
2899         if __debug__:
2900             self._complainaboutunusedargs(callalarmslotinuserequest,kwargs)
2901         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2902         # Make all P fields that haven't already been constructed
2903 
2904 
2905     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2906         'Writes this packet to the supplied buffer'
2907         self._bufferstartoffset=buf.getcurrentoffset()
2908         try: self.__field_header
2909         except:
2910             self.__field_header=qcpheader(**{'packettype': 0x0d, 'command': 0x76})
2911         self.__field_header.writetobuffer(buf)
2912         self.__field_slot.writetobuffer(buf)
2913         try: self.__field_pad
2914         except:
2915             self.__field_pad=UNKNOWN(**{'sizeinbytes': 129})
2916         self.__field_pad.writetobuffer(buf)
2917         self._bufferendoffset=buf.getcurrentoffset()
2918         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2919 
2920 
2921     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2922         'Reads this packet from the supplied buffer'
2923         self._bufferstartoffset=buf.getcurrentoffset()
2924         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2925         self.__field_header=qcpheader(**{'packettype': 0x0d, 'command': 0x76})
2926         self.__field_header.readfrombuffer(buf)
2927         self.__field_slot=UINT(**{'sizeinbytes': 1})
2928         self.__field_slot.readfrombuffer(buf)
2929         self.__field_pad=UNKNOWN(**{'sizeinbytes': 129})
2930         self.__field_pad.readfrombuffer(buf)
2931         self._bufferendoffset=buf.getcurrentoffset()
2932 
2933 
2934     def __getfield_header(self):
2935         try: self.__field_header
2936         except:
2937             self.__field_header=qcpheader(**{'packettype': 0x0d, 'command': 0x76})
2938         return self.__field_header.getvalue()
2939 
2940     def __setfield_header(self, value):
2941         if isinstance(value,qcpheader):
2942             self.__field_header=value
2943         else:
2944             self.__field_header=qcpheader(value,**{'packettype': 0x0d, 'command': 0x76})
2945 
2946     def __delfield_header(self): del self.__field_header
2947 
2948     header=property(__getfield_header, __setfield_header, __delfield_header, None)
2949 
2950     def __getfield_slot(self):
2951         return self.__field_slot.getvalue()
2952 
2953     def __setfield_slot(self, value):
2954         if isinstance(value,UINT):
2955             self.__field_slot=value
2956         else:
2957             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
2958 
2959     def __delfield_slot(self): del self.__field_slot
2960 
2961     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
2962 
2963     def __getfield_pad(self):
2964         try: self.__field_pad
2965         except:
2966             self.__field_pad=UNKNOWN(**{'sizeinbytes': 129})
2967         return self.__field_pad.getvalue()
2968 
2969     def __setfield_pad(self, value):
2970         if isinstance(value,UNKNOWN):
2971             self.__field_pad=value
2972         else:
2973             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 129})
2974 
2975     def __delfield_pad(self): del self.__field_pad
2976 
2977     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
2978 
2979     def iscontainer(self):
2980         return True
2981 
2982     def containerelements(self):
2983         yield ('header', self.__field_header, None)
2984         yield ('slot', self.__field_slot, None)
2985         yield ('pad', self.__field_pad, None)
2986 
2987 
2988 
2989 
2990 class callalarmslotinuseresponse(BaseProtogenClass):
2991     __fields=['header', 'slot', 'flag', 'pad']
2992 
2993     def __init__(self, *args, **kwargs):
2994         dict={}
2995         # What was supplied to this function
2996         dict.update(kwargs)
2997         # Parent constructor
2998         super(callalarmslotinuseresponse,self).__init__(**dict)
2999         if self.__class__ is callalarmslotinuseresponse:
3000             self._update(args,dict)
3001 
3002 
3003     def getfields(self):
3004         return self.__fields
3005 
3006 
3007     def _update(self, args, kwargs):
3008         super(callalarmslotinuseresponse,self)._update(args,kwargs)
3009         keys=kwargs.keys()
3010         for key in keys:
3011             if key in self.__fields:
3012                 setattr(self, key, kwargs[key])
3013                 del kwargs[key]
3014         # Were any unrecognized kwargs passed in?
3015         if __debug__:
3016             self._complainaboutunusedargs(callalarmslotinuseresponse,kwargs)
3017         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3018         # Make all P fields that haven't already been constructed
3019 
3020 
3021     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3022         'Writes this packet to the supplied buffer'
3023         self._bufferstartoffset=buf.getcurrentoffset()
3024         self.__field_header.writetobuffer(buf)
3025         self.__field_slot.writetobuffer(buf)
3026         self.__field_flag.writetobuffer(buf)
3027         self.__field_pad.writetobuffer(buf)
3028         self._bufferendoffset=buf.getcurrentoffset()
3029         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3030 
3031 
3032     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3033         'Reads this packet from the supplied buffer'
3034         self._bufferstartoffset=buf.getcurrentoffset()
3035         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3036         self.__field_header=qcpheader()
3037         self.__field_header.readfrombuffer(buf)
3038         self.__field_slot=UINT(**{'sizeinbytes': 1})
3039         self.__field_slot.readfrombuffer(buf)
3040         self.__field_flag=UINT(**{'sizeinbytes': 1})
3041         self.__field_flag.readfrombuffer(buf)
3042         self.__field_pad=UNKNOWN()
3043         self.__field_pad.readfrombuffer(buf)
3044         self._bufferendoffset=buf.getcurrentoffset()
3045 
3046 
3047     def __getfield_header(self):
3048         return self.__field_header.getvalue()
3049 
3050     def __setfield_header(self, value):
3051         if isinstance(value,qcpheader):
3052             self.__field_header=value
3053         else:
3054             self.__field_header=qcpheader(value,)
3055 
3056     def __delfield_header(self): del self.__field_header
3057 
3058     header=property(__getfield_header, __setfield_header, __delfield_header, None)
3059 
3060     def __getfield_slot(self):
3061         return self.__field_slot.getvalue()
3062 
3063     def __setfield_slot(self, value):
3064         if isinstance(value,UINT):
3065             self.__field_slot=value
3066         else:
3067             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
3068 
3069     def __delfield_slot(self): del self.__field_slot
3070 
3071     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
3072 
3073     def __getfield_flag(self):
3074         return self.__field_flag.getvalue()
3075 
3076     def __setfield_flag(self, value):
3077         if isinstance(value,UINT):
3078             self.__field_flag=value
3079         else:
3080             self.__field_flag=UINT(value,**{'sizeinbytes': 1})
3081 
3082     def __delfield_flag(self): del self.__field_flag
3083 
3084     flag=property(__getfield_flag, __setfield_flag, __delfield_flag, None)
3085 
3086     def __getfield_pad(self):
3087         return self.__field_pad.getvalue()
3088 
3089     def __setfield_pad(self, value):
3090         if isinstance(value,UNKNOWN):
3091             self.__field_pad=value
3092         else:
3093             self.__field_pad=UNKNOWN(value,)
3094 
3095     def __delfield_pad(self): del self.__field_pad
3096 
3097     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
3098 
3099     def iscontainer(self):
3100         return True
3101 
3102     def containerelements(self):
3103         yield ('header', self.__field_header, None)
3104         yield ('slot', self.__field_slot, None)
3105         yield ('flag', self.__field_flag, None)
3106         yield ('pad', self.__field_pad, None)
3107 
3108 
3109 
3110 
3111 class callalarmentry(BaseProtogenClass):
3112     __fields=['slot', 'pad0', 'phonenum', 'phonenum_len', 'date', 'period', 'dom', 'datedup', 'name', 'pad1', 'name_len', 'phonenumbertype', 'phonenumberslot', 'pad2', 'serial', 'pad3', 'ringtone', 'pad4', 'flag']
3113 
3114     def __init__(self, *args, **kwargs):
3115         dict={}
3116         # What was supplied to this function
3117         dict.update(kwargs)
3118         # Parent constructor
3119         super(callalarmentry,self).__init__(**dict)
3120         if self.__class__ is callalarmentry:
3121             self._update(args,dict)
3122 
3123 
3124     def getfields(self):
3125         return self.__fields
3126 
3127 
3128     def _update(self, args, kwargs):
3129         super(callalarmentry,self)._update(args,kwargs)
3130         keys=kwargs.keys()
3131         for key in keys:
3132             if key in self.__fields:
3133                 setattr(self, key, kwargs[key])
3134                 del kwargs[key]
3135         # Were any unrecognized kwargs passed in?
3136         if __debug__:
3137             self._complainaboutunusedargs(callalarmentry,kwargs)
3138         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3139         # Make all P fields that haven't already been constructed
3140 
3141 
3142     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3143         'Writes this packet to the supplied buffer'
3144         self._bufferstartoffset=buf.getcurrentoffset()
3145         self.__field_slot.writetobuffer(buf)
3146         try: self.__field_pad0
3147         except:
3148             self.__field_pad0=UNKNOWN(**{'sizeinbytes': 1})
3149         self.__field_pad0.writetobuffer(buf)
3150         self.__field_phonenum.writetobuffer(buf)
3151         self.__field_phonenum_len.writetobuffer(buf)
3152         self.__field_date.writetobuffer(buf)
3153         self.__field_period.writetobuffer(buf)
3154         self.__field_dom.writetobuffer(buf)
3155         self.__field_datedup.writetobuffer(buf)
3156         self.__field_name.writetobuffer(buf)
3157         try: self.__field_pad1
3158         except:
3159             self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1})
3160         self.__field_pad1.writetobuffer(buf)
3161         self.__field_name_len.writetobuffer(buf)
3162         self.__field_phonenumbertype.writetobuffer(buf)
3163         self.__field_phonenumberslot.writetobuffer(buf)
3164         try: self.__field_pad2
3165         except:
3166             self.__field_pad2=UNKNOWN(**{'sizeinbytes': 1})
3167         self.__field_pad2.writetobuffer(buf)
3168         try: self.__field_serial
3169         except:
3170             self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0})
3171         self.__field_serial.writetobuffer(buf)
3172         try: self.__field_pad3
3173         except:
3174             self.__field_pad3=UNKNOWN(**{'sizeinbytes': 2})
3175         self.__field_pad3.writetobuffer(buf)
3176         try: self.__field_ringtone
3177         except:
3178             self.__field_ringtone=UINT(**{'sizeinbytes': 1, 'default': 0xfc})
3179         self.__field_ringtone.writetobuffer(buf)
3180         try: self.__field_pad4
3181         except:
3182             self.__field_pad4=UNKNOWN(**{'sizeinbytes': 1})
3183         self.__field_pad4.writetobuffer(buf)
3184         try: self.__field_flag
3185         except:
3186             self.__field_flag=UINT(**{'sizeinbytes': 1})
3187         self.__field_flag.writetobuffer(buf)
3188         self._bufferendoffset=buf.getcurrentoffset()
3189         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3190 
3191 
3192     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3193         'Reads this packet from the supplied buffer'
3194         self._bufferstartoffset=buf.getcurrentoffset()
3195         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3196         self.__field_slot=UINT(**{'sizeinbytes': 1})
3197         self.__field_slot.readfrombuffer(buf)
3198         self.__field_pad0=UNKNOWN(**{'sizeinbytes': 1})
3199         self.__field_pad0.readfrombuffer(buf)
3200         self.__field_phonenum=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
3201         self.__field_phonenum.readfrombuffer(buf)
3202         self.__field_phonenum_len=UINT(**{'sizeinbytes': 1})
3203         self.__field_phonenum_len.readfrombuffer(buf)
3204         self.__field_date=UINT(**{'sizeinbytes': 4})
3205         self.__field_date.readfrombuffer(buf)
3206         self.__field_period=UINT(**{'sizeinbytes': 1})
3207         self.__field_period.readfrombuffer(buf)
3208         self.__field_dom=UINT(**{'sizeinbytes': 1})
3209         self.__field_dom.readfrombuffer(buf)
3210         self.__field_datedup=UINT(**{'sizeinbytes': 4})
3211         self.__field_datedup.readfrombuffer(buf)
3212         self.__field_name=USTRING(**{'sizeinbytes': 16, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})
3213         self.__field_name.readfrombuffer(buf)
3214         self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1})
3215         self.__field_pad1.readfrombuffer(buf)
3216         self.__field_name_len=UINT(**{'sizeinbytes': 1})
3217         self.__field_name_len.readfrombuffer(buf)
3218         self.__field_phonenumbertype=UINT(**{'sizeinbytes': 1})
3219         self.__field_phonenumbertype.readfrombuffer(buf)
3220         self.__field_phonenumberslot=UINT(**{'sizeinbytes': 2})
3221         self.__field_phonenumberslot.readfrombuffer(buf)
3222         self.__field_pad2=UNKNOWN(**{'sizeinbytes': 1})
3223         self.__field_pad2.readfrombuffer(buf)
3224         self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0})
3225         self.__field_serial.readfrombuffer(buf)
3226         self.__field_pad3=UNKNOWN(**{'sizeinbytes': 2})
3227         self.__field_pad3.readfrombuffer(buf)
3228         self.__field_ringtone=UINT(**{'sizeinbytes': 1, 'default': 0xfc})
3229         self.__field_ringtone.readfrombuffer(buf)
3230         self.__field_pad4=UNKNOWN(**{'sizeinbytes': 1})
3231         self.__field_pad4.readfrombuffer(buf)
3232         self.__field_flag=UINT(**{'sizeinbytes': 1})
3233         self.__field_flag.readfrombuffer(buf)
3234         self._bufferendoffset=buf.getcurrentoffset()
3235 
3236 
3237     def __getfield_slot(self):
3238         return self.__field_slot.getvalue()
3239 
3240     def __setfield_slot(self, value):
3241         if isinstance(value,UINT):
3242             self.__field_slot=value
3243         else:
3244             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
3245 
3246     def __delfield_slot(self): del self.__field_slot
3247 
3248     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
3249 
3250     def __getfield_pad0(self):
3251         try: self.__field_pad0
3252         except:
3253             self.__field_pad0=UNKNOWN(**{'sizeinbytes': 1})
3254         return self.__field_pad0.getvalue()
3255 
3256     def __setfield_pad0(self, value):
3257         if isinstance(value,UNKNOWN):
3258             self.__field_pad0=value
3259         else:
3260             self.__field_pad0=UNKNOWN(value,**{'sizeinbytes': 1})
3261 
3262     def __delfield_pad0(self): del self.__field_pad0
3263 
3264     pad0=property(__getfield_pad0, __setfield_pad0, __delfield_pad0, "Not the flag?")
3265 
3266     def __getfield_phonenum(self):
3267         return self.__field_phonenum.getvalue()
3268 
3269     def __setfield_phonenum(self, value):
3270         if isinstance(value,USTRING):
3271             self.__field_phonenum=value
3272         else:
3273             self.__field_phonenum=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
3274 
3275     def __delfield_phonenum(self): del self.__field_phonenum
3276 
3277     phonenum=property(__getfield_phonenum, __setfield_phonenum, __delfield_phonenum, None)
3278 
3279     def __getfield_phonenum_len(self):
3280         return self.__field_phonenum_len.getvalue()
3281 
3282     def __setfield_phonenum_len(self, value):
3283         if isinstance(value,UINT):
3284             self.__field_phonenum_len=value
3285         else:
3286             self.__field_phonenum_len=UINT(value,**{'sizeinbytes': 1})
3287 
3288     def __delfield_phonenum_len(self): del self.__field_phonenum_len
3289 
3290     phonenum_len=property(__getfield_phonenum_len, __setfield_phonenum_len, __delfield_phonenum_len, None)
3291 
3292     def __getfield_date(self):
3293         return self.__field_date.getvalue()
3294 
3295     def __setfield_date(self, value):
3296         if isinstance(value,UINT):
3297             self.__field_date=value
3298         else:
3299             self.__field_date=UINT(value,**{'sizeinbytes': 4})
3300 
3301     def __delfield_date(self): del self.__field_date
3302 
3303     date=property(__getfield_date, __setfield_date, __delfield_date, "# seconds since Jan 1, 1980 approximately")
3304 
3305     def __getfield_period(self):
3306         return self.__field_period.getvalue()
3307 
3308     def __setfield_period(self, value):
3309         if isinstance(value,UINT):
3310             self.__field_period=value
3311         else:
3312             self.__field_period=UINT(value,**{'sizeinbytes': 1})
3313 
3314     def __delfield_period(self): del self.__field_period
3315 
3316     period=property(__getfield_period, __setfield_period, __delfield_period, "No, Daily, Weekly, Monthly, Yearly")
3317 
3318     def __getfield_dom(self):
3319         return self.__field_dom.getvalue()
3320 
3321     def __setfield_dom(self, value):
3322         if isinstance(value,UINT):
3323             self.__field_dom=value
3324         else:
3325             self.__field_dom=UINT(value,**{'sizeinbytes': 1})
3326 
3327     def __delfield_dom(self): del self.__field_dom
3328 
3329     dom=property(__getfield_dom, __setfield_dom, __delfield_dom, "Day of month for the event")
3330 
3331     def __getfield_datedup(self):
3332         return self.__field_datedup.getvalue()
3333 
3334     def __setfield_datedup(self, value):
3335         if isinstance(value,UINT):
3336             self.__field_datedup=value
3337         else:
3338             self.__field_datedup=UINT(value,**{'sizeinbytes': 4})
3339 
3340     def __delfield_datedup(self): del self.__field_datedup
3341 
3342     datedup=property(__getfield_datedup, __setfield_datedup, __delfield_datedup, "Copy of the date.  Always the same???")
3343 
3344     def __getfield_name(self):
3345         return self.__field_name.getvalue()
3346 
3347     def __setfield_name(self, value):
3348         if isinstance(value,USTRING):
3349             self.__field_name=value
3350         else:
3351             self.__field_name=USTRING(value,**{'sizeinbytes': 16, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})
3352 
3353     def __delfield_name(self): del self.__field_name
3354 
3355     name=property(__getfield_name, __setfield_name, __delfield_name, None)
3356 
3357     def __getfield_pad1(self):
3358         try: self.__field_pad1
3359         except:
3360             self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1})
3361         return self.__field_pad1.getvalue()
3362 
3363     def __setfield_pad1(self, value):
3364         if isinstance(value,UNKNOWN):
3365             self.__field_pad1=value
3366         else:
3367             self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 1})
3368 
3369     def __delfield_pad1(self): del self.__field_pad1
3370 
3371     pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None)
3372 
3373     def __getfield_name_len(self):
3374         return self.__field_name_len.getvalue()
3375 
3376     def __setfield_name_len(self, value):
3377         if isinstance(value,UINT):
3378             self.__field_name_len=value
3379         else:
3380             self.__field_name_len=UINT(value,**{'sizeinbytes': 1})
3381 
3382     def __delfield_name_len(self): del self.__field_name_len
3383 
3384     name_len=property(__getfield_name_len, __setfield_name_len, __delfield_name_len, None)
3385 
3386     def __getfield_phonenumbertype(self):
3387         return self.__field_phonenumbertype.getvalue()
3388 
3389     def __setfield_phonenumbertype(self, value):
3390         if isinstance(value,UINT):
3391             self.__field_phonenumbertype=value
3392         else:
3393             self.__field_phonenumbertype=UINT(value,**{'sizeinbytes': 1})
3394 
3395     def __delfield_phonenumbertype(self): del self.__field_phonenumbertype
3396 
3397     phonenumbertype=property(__getfield_phonenumbertype, __setfield_phonenumbertype, __delfield_phonenumbertype, "1: Home, 2: Work, ...")
3398 
3399     def __getfield_phonenumberslot(self):
3400         return self.__field_phonenumberslot.getvalue()
3401 
3402     def __setfield_phonenumberslot(self, value):
3403         if isinstance(value,UINT):
3404             self.__field_phonenumberslot=value
3405         else:
3406             self.__field_phonenumberslot=UINT(value,**{'sizeinbytes': 2})
3407 
3408     def __delfield_phonenumberslot(self): del self.__field_phonenumberslot
3409 
3410     phonenumberslot=property(__getfield_phonenumberslot, __setfield_phonenumberslot, __delfield_phonenumberslot, None)
3411 
3412     def __getfield_pad2(self):
3413         try: self.__field_pad2
3414         except:
3415             self.__field_pad2=UNKNOWN(**{'sizeinbytes': 1})
3416         return self.__field_pad2.getvalue()
3417 
3418     def __setfield_pad2(self, value):
3419         if isinstance(value,UNKNOWN):
3420             self.__field_pad2=value
3421         else:
3422             self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 1})
3423 
3424     def __delfield_pad2(self): del self.__field_pad2
3425 
3426     pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None)
3427 
3428     def __getfield_serial(self):
3429         try: self.__field_serial
3430         except:
3431             self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0})
3432         return self.__field_serial.getvalue()
3433 
3434     def __setfield_serial(self, value):
3435         if isinstance(value,UINT):
3436             self.__field_serial=value
3437         else:
3438             self.__field_serial=UINT(value,**{'sizeinbytes': 1, 'default': 0})
3439 
3440     def __delfield_serial(self): del self.__field_serial
3441 
3442     serial=property(__getfield_serial, __setfield_serial, __delfield_serial, None)
3443 
3444     def __getfield_pad3(self):
3445         try: self.__field_pad3
3446         except:
3447             self.__field_pad3=UNKNOWN(**{'sizeinbytes': 2})
3448         return self.__field_pad3.getvalue()
3449 
3450     def __setfield_pad3(self, value):
3451         if isinstance(value,UNKNOWN):
3452             self.__field_pad3=value
3453         else:
3454             self.__field_pad3=UNKNOWN(value,**{'sizeinbytes': 2})
3455 
3456     def __delfield_pad3(self): del self.__field_pad3
3457 
3458     pad3=property(__getfield_pad3, __setfield_pad3, __delfield_pad3, None)
3459 
3460     def __getfield_ringtone(self):
3461         try: self.__field_ringtone
3462         except:
3463             self.__field_ringtone=UINT(**{'sizeinbytes': 1, 'default': 0xfc})
3464         return self.__field_ringtone.getvalue()
3465 
3466     def __setfield_ringtone(self, value):
3467         if isinstance(value,UINT):
3468             self.__field_ringtone=value
3469         else:
3470             self.__field_ringtone=UINT(value,**{'sizeinbytes': 1, 'default': 0xfc})
3471 
3472     def __delfield_ringtone(self): del self.__field_ringtone
3473 
3474     ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None)
3475 
3476     def __getfield_pad4(self):
3477         try: self.__field_pad4
3478         except:
3479             self.__field_pad4=UNKNOWN(**{'sizeinbytes': 1})
3480         return self.__field_pad4.getvalue()
3481 
3482     def __setfield_pad4(self, value):
3483         if isinstance(value,UNKNOWN):
3484             self.__field_pad4=value
3485         else:
3486             self.__field_pad4=UNKNOWN(value,**{'sizeinbytes': 1})
3487 
3488     def __delfield_pad4(self): del self.__field_pad4
3489 
3490     pad4=property(__getfield_pad4, __setfield_pad4, __delfield_pad4, " This may be the ringtone.  Need to understand ")
3491 
3492     def __getfield_flag(self):
3493         try: self.__field_flag
3494         except:
3495             self.__field_flag=UINT(**{'sizeinbytes': 1})
3496         return self.__field_flag.getvalue()
3497 
3498     def __setfield_flag(self, value):
3499         if isinstance(value,UINT):
3500             self.__field_flag=value
3501         else:
3502             self.__field_flag=UINT(value,**{'sizeinbytes': 1})
3503 
3504     def __delfield_flag(self): del self.__field_flag
3505 
3506     flag=property(__getfield_flag, __setfield_flag, __delfield_flag, None)
3507 
3508     def iscontainer(self):
3509         return True
3510 
3511     def containerelements(self):
3512         yield ('slot', self.__field_slot, None)
3513         yield ('pad0', self.__field_pad0, "Not the flag?")
3514         yield ('phonenum', self.__field_phonenum, None)
3515         yield ('phonenum_len', self.__field_phonenum_len, None)
3516         yield ('date', self.__field_date, "# seconds since Jan 1, 1980 approximately")
3517         yield ('period', self.__field_period, "No, Daily, Weekly, Monthly, Yearly")
3518         yield ('dom', self.__field_dom, "Day of month for the event")
3519         yield ('datedup', self.__field_datedup, "Copy of the date.  Always the same???")
3520         yield ('name', self.__field_name, None)
3521         yield ('pad1', self.__field_pad1, None)
3522         yield ('name_len', self.__field_name_len, None)
3523         yield ('phonenumbertype', self.__field_phonenumbertype, "1: Home, 2: Work, ...")
3524         yield ('phonenumberslot', self.__field_phonenumberslot, None)
3525         yield ('pad2', self.__field_pad2, None)
3526         yield ('serial', self.__field_serial, None)
3527         yield ('pad3', self.__field_pad3, None)
3528         yield ('ringtone', self.__field_ringtone, None)
3529         yield ('pad4', self.__field_pad4, " This may be the ringtone.  Need to understand ")
3530         yield ('flag', self.__field_flag, None)
3531 
3532 
3533 
3534 
3535