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