PyXR

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

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