Source Code for Module phones.p_sanyo8300

   1  # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE 
   2   
   3  """Various descriptions of data specific to Sanyo MM-8300""" 
   4   
   5  from prototypes import * 
   6   
   7  # Make all sanyo stuff available in this module as well 
   8  from p_sanyo import * 
   9  from p_sanyomedia import * 
  10  from p_sanyonewer import * 
  11   
  12  # We use LSB for all integer like fields 
  13  UINT=UINTlsb 
  14  BOOL=BOOLlsb 
  15  _NUMPBSLOTS=300 
  16  _NUMSPEEDDIALS=8 
  17  _NUMLONGNUMBERS=5 
  18  _LONGPHONENUMBERLEN=30 
  19  _NUMEVENTSLOTS=100 
  20  _NUMCALLALARMSLOTS=15 
  21   # Need to check.  Is max phone will hold 32/96 or 33/97 
  22  _MAXNUMBERLEN=32 
  23  _MAXEMAILLEN=96 
  24  HASRINGPICBUF=0 
  25   
  26  #BREW_FILE_SYSTEM=2 
  27   
  28 -class qcpheader(BaseProtogenClass): 
  29      __fields=['readwrite', 'command', 'packettype'] 
  30   
  31 -    def __init__(self, *args, **kwargs): 
  32          dict={} 
  33          # User specified arguments in the packet description 
  34          dict.update({'readwrite': 0x26}) 
  35          # What was supplied to this function 
  36          dict.update(kwargs) 
  37          # Parent constructor 
  38          super(qcpheader,self).__init__(**dict) 
  39          if self.__class__ is qcpheader: 
  40              self._update(args,dict) 
  41   
  42   
  43 -    def getfields(self): 
  44          return self.__fields 
  45   
  46   
  47 -    def _update(self, args, kwargs): 
  48          super(qcpheader,self)._update(args,kwargs) 
  49          keys=kwargs.keys() 
  50          for key in keys: 
  51              if key in self.__fields: 
  52                  setattr(self, key, kwargs[key]) 
  53                  del kwargs[key] 
  54          # Were any unrecognized kwargs passed in? 
  55          if __debug__: 
  56              self._complainaboutunusedargs(qcpheader,kwargs) 
  57          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
  58          # Make all P fields that haven't already been constructed 
  59   
  60   
  61 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
  62          'Writes this packet to the supplied buffer' 
  63          self._bufferstartoffset=buf.getcurrentoffset() 
  64          self.__field_readwrite.writetobuffer(buf) 
  65          self.__field_command.writetobuffer(buf) 
  66          self.__field_packettype.writetobuffer(buf) 
  67          self._bufferendoffset=buf.getcurrentoffset() 
  68          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
  69   
  70   
  71 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
  72          'Reads this packet from the supplied buffer' 
  73          self._bufferstartoffset=buf.getcurrentoffset() 
  74          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
  75          self.__field_readwrite=UINT(**{'sizeinbytes': 1}) 
  76          self.__field_readwrite.readfrombuffer(buf) 
  77          self.__field_command=UINT(**{'sizeinbytes': 1}) 
  78          self.__field_command.readfrombuffer(buf) 
  79          self.__field_packettype=UINT(**{'sizeinbytes': 1}) 
  80          self.__field_packettype.readfrombuffer(buf) 
  81          self._bufferendoffset=buf.getcurrentoffset() 
  82   
  83   
  84 -    def __getfield_readwrite(self): 
  85          return self.__field_readwrite.getvalue() 
  86   
  87 -    def __setfield_readwrite(self, value): 
  88          if isinstance(value,UINT): 
  89              self.__field_readwrite=value 
  90          else: 
  91              self.__field_readwrite=UINT(value,**{'sizeinbytes': 1}) 
  92   
  93 -    def __delfield_readwrite(self): del self.__field_readwrite 
  94   
  95      readwrite=property(__getfield_readwrite, __setfield_readwrite, __delfield_readwrite, None) 
  96   
  97 -    def __getfield_command(self): 
  98          return self.__field_command.getvalue() 
  99   
 100 -    def __setfield_command(self, value): 
 101          if isinstance(value,UINT): 
 102              self.__field_command=value 
 103          else: 
 104              self.__field_command=UINT(value,**{'sizeinbytes': 1}) 
 105   
 106 -    def __delfield_command(self): del self.__field_command 
 107   
 108      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
 109   
 110 -    def __getfield_packettype(self): 
 111          return self.__field_packettype.getvalue() 
 112   
 113 -    def __setfield_packettype(self, value): 
 114          if isinstance(value,UINT): 
 115              self.__field_packettype=value 
 116          else: 
 117              self.__field_packettype=UINT(value,**{'sizeinbytes': 1}) 
 118   
 119 -    def __delfield_packettype(self): del self.__field_packettype 
 120   
 121      packettype=property(__getfield_packettype, __setfield_packettype, __delfield_packettype, None) 
 122   
 123 -    def iscontainer(self): 
 124          return True 
 125   
 126 -    def containerelements(self): 
 127          yield ('readwrite', self.__field_readwrite, None) 
 128          yield ('command', self.__field_command, None) 
 129          yield ('packettype', self.__field_packettype, None) 
 130   
 131   
 132   
 133   
 134 -class qcpwriteheader(BaseProtogenClass): 
 135      __fields=['readwrite', 'command', 'packettype'] 
 136   
 137 -    def __init__(self, *args, **kwargs): 
 138          dict={} 
 139          # User specified arguments in the packet description 
 140          dict.update({'readwrite': 0x27}) 
 141          # What was supplied to this function 
 142          dict.update(kwargs) 
 143          # Parent constructor 
 144          super(qcpwriteheader,self).__init__(**dict) 
 145          if self.__class__ is qcpwriteheader: 
 146              self._update(args,dict) 
 147   
 148   
 149 -    def getfields(self): 
 150          return self.__fields 
 151   
 152   
 153 -    def _update(self, args, kwargs): 
 154          super(qcpwriteheader,self)._update(args,kwargs) 
 155          keys=kwargs.keys() 
 156          for key in keys: 
 157              if key in self.__fields: 
 158                  setattr(self, key, kwargs[key]) 
 159                  del kwargs[key] 
 160          # Were any unrecognized kwargs passed in? 
 161          if __debug__: 
 162              self._complainaboutunusedargs(qcpwriteheader,kwargs) 
 163          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 164          # Make all P fields that haven't already been constructed 
 165   
 166   
 167 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 168          'Writes this packet to the supplied buffer' 
 169          self._bufferstartoffset=buf.getcurrentoffset() 
 170          self.__field_readwrite.writetobuffer(buf) 
 171          self.__field_command.writetobuffer(buf) 
 172          self.__field_packettype.writetobuffer(buf) 
 173          self._bufferendoffset=buf.getcurrentoffset() 
 174          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 175   
 176   
 177 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 178          'Reads this packet from the supplied buffer' 
 179          self._bufferstartoffset=buf.getcurrentoffset() 
 180          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 181          self.__field_readwrite=UINT(**{'sizeinbytes': 1}) 
 182          self.__field_readwrite.readfrombuffer(buf) 
 183          self.__field_command=UINT(**{'sizeinbytes': 1}) 
 184          self.__field_command.readfrombuffer(buf) 
 185          self.__field_packettype=UINT(**{'sizeinbytes': 1}) 
 186          self.__field_packettype.readfrombuffer(buf) 
 187          self._bufferendoffset=buf.getcurrentoffset() 
 188   
 189   
 190 -    def __getfield_readwrite(self): 
 191          return self.__field_readwrite.getvalue() 
 192   
 193 -    def __setfield_readwrite(self, value): 
 194          if isinstance(value,UINT): 
 195              self.__field_readwrite=value 
 196          else: 
 197              self.__field_readwrite=UINT(value,**{'sizeinbytes': 1}) 
 198   
 199 -    def __delfield_readwrite(self): del self.__field_readwrite 
 200   
 201      readwrite=property(__getfield_readwrite, __setfield_readwrite, __delfield_readwrite, None) 
 202   
 203 -    def __getfield_command(self): 
 204          return self.__field_command.getvalue() 
 205   
 206 -    def __setfield_command(self, value): 
 207          if isinstance(value,UINT): 
 208              self.__field_command=value 
 209          else: 
 210              self.__field_command=UINT(value,**{'sizeinbytes': 1}) 
 211   
 212 -    def __delfield_command(self): del self.__field_command 
 213   
 214      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
 215   
 216 -    def __getfield_packettype(self): 
 217          return self.__field_packettype.getvalue() 
 218   
 219 -    def __setfield_packettype(self, value): 
 220          if isinstance(value,UINT): 
 221              self.__field_packettype=value 
 222          else: 
 223              self.__field_packettype=UINT(value,**{'sizeinbytes': 1}) 
 224   
 225 -    def __delfield_packettype(self): del self.__field_packettype 
 226   
 227      packettype=property(__getfield_packettype, __setfield_packettype, __delfield_packettype, None) 
 228   
 229 -    def iscontainer(self): 
 230          return True 
 231   
 232 -    def containerelements(self): 
 233          yield ('readwrite', self.__field_readwrite, None) 
 234          yield ('command', self.__field_command, None) 
 235          yield ('packettype', self.__field_packettype, None) 
 236   
 237   
 238   
 239   
 240 -class eventrequest(BaseProtogenClass): 
 241      __fields=['header', 'slot', 'pad'] 
 242   
 243 -    def __init__(self, *args, **kwargs): 
 244          dict={} 
 245          # What was supplied to this function 
 246          dict.update(kwargs) 
 247          # Parent constructor 
 248          super(eventrequest,self).__init__(**dict) 
 249          if self.__class__ is eventrequest: 
 250              self._update(args,dict) 
 251   
 252   
 253 -    def getfields(self): 
 254          return self.__fields 
 255   
 256   
 257 -    def _update(self, args, kwargs): 
 258          super(eventrequest,self)._update(args,kwargs) 
 259          keys=kwargs.keys() 
 260          for key in keys: 
 261              if key in self.__fields: 
 262                  setattr(self, key, kwargs[key]) 
 263                  del kwargs[key] 
 264          # Were any unrecognized kwargs passed in? 
 265          if __debug__: 
 266              self._complainaboutunusedargs(eventrequest,kwargs) 
 267          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 268          # Make all P fields that haven't already been constructed 
 269   
 270   
 271 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 272          'Writes this packet to the supplied buffer' 
 273          self._bufferstartoffset=buf.getcurrentoffset() 
 274          try: self.__field_header 
 275          except: 
 276              self.__field_header=qcpheader(**{'packettype': 0x0c, 'command': 0x23}) 
 277          self.__field_header.writetobuffer(buf) 
 278          self.__field_slot.writetobuffer(buf) 
 279          try: self.__field_pad 
 280          except: 
 281              self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 
 282          self.__field_pad.writetobuffer(buf) 
 283          self._bufferendoffset=buf.getcurrentoffset() 
 284          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 285   
 286   
 287 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 288          'Reads this packet from the supplied buffer' 
 289          self._bufferstartoffset=buf.getcurrentoffset() 
 290          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 291          self.__field_header=qcpheader(**{'packettype': 0x0c, 'command': 0x23}) 
 292          self.__field_header.readfrombuffer(buf) 
 293          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
 294          self.__field_slot.readfrombuffer(buf) 
 295          self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 
 296          self.__field_pad.readfrombuffer(buf) 
 297          self._bufferendoffset=buf.getcurrentoffset() 
 298   
 299   
 300 -    def __getfield_header(self): 
 301          try: self.__field_header 
 302          except: 
 303              self.__field_header=qcpheader(**{'packettype': 0x0c, 'command': 0x23}) 
 304          return self.__field_header.getvalue() 
 305   
 306 -    def __setfield_header(self, value): 
 307          if isinstance(value,qcpheader): 
 308              self.__field_header=value 
 309          else: 
 310              self.__field_header=qcpheader(value,**{'packettype': 0x0c, 'command': 0x23}) 
 311   
 312 -    def __delfield_header(self): del self.__field_header 
 313   
 314      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
 315   
 316 -    def __getfield_slot(self): 
 317          return self.__field_slot.getvalue() 
 318   
 319 -    def __setfield_slot(self, value): 
 320          if isinstance(value,UINT): 
 321              self.__field_slot=value 
 322          else: 
 323              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
 324   
 325 -    def __delfield_slot(self): del self.__field_slot 
 326   
 327      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
 328   
 329 -    def __getfield_pad(self): 
 330          try: self.__field_pad 
 331          except: 
 332              self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 
 333          return self.__field_pad.getvalue() 
 334   
 335 -    def __setfield_pad(self, value): 
 336          if isinstance(value,UNKNOWN): 
 337              self.__field_pad=value 
 338          else: 
 339              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 129}) 
 340   
 341 -    def __delfield_pad(self): del self.__field_pad 
 342   
 343      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
 344   
 345 -    def iscontainer(self): 
 346          return True 
 347   
 348 -    def containerelements(self): 
 349          yield ('header', self.__field_header, None) 
 350          yield ('slot', self.__field_slot, None) 
 351          yield ('pad', self.__field_pad, None) 
 352   
 353   
 354   
 355   
 356 -class eventslotinuserequest(BaseProtogenClass): 
 357      __fields=['header', 'slot', 'pad'] 
 358   
 359 -    def __init__(self, *args, **kwargs): 
 360          dict={} 
 361          # What was supplied to this function 
 362          dict.update(kwargs) 
 363          # Parent constructor 
 364          super(eventslotinuserequest,self).__init__(**dict) 
 365          if self.__class__ is eventslotinuserequest: 
 366              self._update(args,dict) 
 367   
 368   
 369 -    def getfields(self): 
 370          return self.__fields 
 371   
 372   
 373 -    def _update(self, args, kwargs): 
 374          super(eventslotinuserequest,self)._update(args,kwargs) 
 375          keys=kwargs.keys() 
 376          for key in keys: 
 377              if key in self.__fields: 
 378                  setattr(self, key, kwargs[key]) 
 379                  del kwargs[key] 
 380          # Were any unrecognized kwargs passed in? 
 381          if __debug__: 
 382              self._complainaboutunusedargs(eventslotinuserequest,kwargs) 
 383          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 384          # Make all P fields that haven't already been constructed 
 385   
 386   
 387 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 388          'Writes this packet to the supplied buffer' 
 389          self._bufferstartoffset=buf.getcurrentoffset() 
 390          try: self.__field_header 
 391          except: 
 392              self.__field_header=qcpheader(**{'readwrite': 0x26, 'packettype': 0x0d, 'command': 0x74}) 
 393          self.__field_header.writetobuffer(buf) 
 394          self.__field_slot.writetobuffer(buf) 
 395          try: self.__field_pad 
 396          except: 
 397              self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 
 398          self.__field_pad.writetobuffer(buf) 
 399          self._bufferendoffset=buf.getcurrentoffset() 
 400          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 401   
 402   
 403 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 404          'Reads this packet from the supplied buffer' 
 405          self._bufferstartoffset=buf.getcurrentoffset() 
 406          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 407          self.__field_header=qcpheader(**{'readwrite': 0x26, 'packettype': 0x0d, 'command': 0x74}) 
 408          self.__field_header.readfrombuffer(buf) 
 409          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
 410          self.__field_slot.readfrombuffer(buf) 
 411          self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 
 412          self.__field_pad.readfrombuffer(buf) 
 413          self._bufferendoffset=buf.getcurrentoffset() 
 414   
 415   
 416 -    def __getfield_header(self): 
 417          try: self.__field_header 
 418          except: 
 419              self.__field_header=qcpheader(**{'readwrite': 0x26, 'packettype': 0x0d, 'command': 0x74}) 
 420          return self.__field_header.getvalue() 
 421   
 422 -    def __setfield_header(self, value): 
 423          if isinstance(value,qcpheader): 
 424              self.__field_header=value 
 425          else: 
 426              self.__field_header=qcpheader(value,**{'readwrite': 0x26, 'packettype': 0x0d, 'command': 0x74}) 
 427   
 428 -    def __delfield_header(self): del self.__field_header 
 429   
 430      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
 431   
 432 -    def __getfield_slot(self): 
 433          return self.__field_slot.getvalue() 
 434   
 435 -    def __setfield_slot(self, value): 
 436          if isinstance(value,UINT): 
 437              self.__field_slot=value 
 438          else: 
 439              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
 440   
 441 -    def __delfield_slot(self): del self.__field_slot 
 442   
 443      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
 444   
 445 -    def __getfield_pad(self): 
 446          try: self.__field_pad 
 447          except: 
 448              self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 
 449          return self.__field_pad.getvalue() 
 450   
 451 -    def __setfield_pad(self, value): 
 452          if isinstance(value,UNKNOWN): 
 453              self.__field_pad=value 
 454          else: 
 455              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 129}) 
 456   
 457 -    def __delfield_pad(self): del self.__field_pad 
 458   
 459      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
 460   
 461 -    def iscontainer(self): 
 462          return True 
 463   
 464 -    def containerelements(self): 
 465          yield ('header', self.__field_header, None) 
 466          yield ('slot', self.__field_slot, None) 
 467          yield ('pad', self.__field_pad, None) 
 468   
 469   
 470   
 471   
 472 -class evententry(BaseProtogenClass): 
 473      __fields=['slot', 'eventname', 'pad1', 'eventname_len', 'start', 'end', 'location', 'pad2', 'location_len', 'alarmdiff', 'period', 'dom', 'alarm', 'pad3', 'serial', 'pad4', 'ringtone'] 
 474   
 475 -    def __init__(self, *args, **kwargs): 
 476          dict={} 
 477          # What was supplied to this function 
 478          dict.update(kwargs) 
 479          # Parent constructor 
 480          super(evententry,self).__init__(**dict) 
 481          if self.__class__ is evententry: 
 482              self._update(args,dict) 
 483   
 484   
 485 -    def getfields(self): 
 486          return self.__fields 
 487   
 488   
 489 -    def _update(self, args, kwargs): 
 490          super(evententry,self)._update(args,kwargs) 
 491          keys=kwargs.keys() 
 492          for key in keys: 
 493              if key in self.__fields: 
 494                  setattr(self, key, kwargs[key]) 
 495                  del kwargs[key] 
 496          # Were any unrecognized kwargs passed in? 
 497          if __debug__: 
 498              self._complainaboutunusedargs(evententry,kwargs) 
 499          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 500          # Make all P fields that haven't already been constructed 
 501   
 502   
 503 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 504          'Writes this packet to the supplied buffer' 
 505          self._bufferstartoffset=buf.getcurrentoffset() 
 506          self.__field_slot.writetobuffer(buf) 
 507          self.__field_eventname.writetobuffer(buf) 
 508          try: self.__field_pad1 
 509          except: 
 510              self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7}) 
 511          self.__field_pad1.writetobuffer(buf) 
 512          self.__field_eventname_len.writetobuffer(buf) 
 513          self.__field_start.writetobuffer(buf) 
 514          self.__field_end.writetobuffer(buf) 
 515          self.__field_location.writetobuffer(buf) 
 516          try: self.__field_pad2 
 517          except: 
 518              self.__field_pad2=UNKNOWN(**{'sizeinbytes': 7}) 
 519          self.__field_pad2.writetobuffer(buf) 
 520          self.__field_location_len.writetobuffer(buf) 
 521          self.__field_alarmdiff.writetobuffer(buf) 
 522          self.__field_period.writetobuffer(buf) 
 523          self.__field_dom.writetobuffer(buf) 
 524          self.__field_alarm.writetobuffer(buf) 
 525          try: self.__field_pad3 
 526          except: 
 527              self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1}) 
 528          self.__field_pad3.writetobuffer(buf) 
 529          try: self.__field_serial 
 530          except: 
 531              self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 
 532          self.__field_serial.writetobuffer(buf) 
 533          try: self.__field_pad4 
 534          except: 
 535              self.__field_pad4=UNKNOWN(**{'sizeinbytes': 3}) 
 536          self.__field_pad4.writetobuffer(buf) 
 537          self.__field_ringtone.writetobuffer(buf) 
 538          self._bufferendoffset=buf.getcurrentoffset() 
 539          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 540   
 541   
 542 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 543          'Reads this packet from the supplied buffer' 
 544          self._bufferstartoffset=buf.getcurrentoffset() 
 545          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 546          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
 547          self.__field_slot.readfrombuffer(buf) 
 548          self.__field_eventname=USTRING(**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
 549          self.__field_eventname.readfrombuffer(buf) 
 550          self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7}) 
 551          self.__field_pad1.readfrombuffer(buf) 
 552          self.__field_eventname_len=UINT(**{'sizeinbytes': 1}) 
 553          self.__field_eventname_len.readfrombuffer(buf) 
 554          self.__field_start=UINT(**{'sizeinbytes': 4}) 
 555          self.__field_start.readfrombuffer(buf) 
 556          self.__field_end=UINT(**{'sizeinbytes': 4}) 
 557          self.__field_end.readfrombuffer(buf) 
 558          self.__field_location=USTRING(**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
 559          self.__field_location.readfrombuffer(buf) 
 560          self.__field_pad2=UNKNOWN(**{'sizeinbytes': 7}) 
 561          self.__field_pad2.readfrombuffer(buf) 
 562          self.__field_location_len=UINT(**{'sizeinbytes': 1}) 
 563          self.__field_location_len.readfrombuffer(buf) 
 564          self.__field_alarmdiff=UINT(**{'sizeinbytes': 4}) 
 565          self.__field_alarmdiff.readfrombuffer(buf) 
 566          self.__field_period=UINT(**{'sizeinbytes': 1}) 
 567          self.__field_period.readfrombuffer(buf) 
 568          self.__field_dom=UINT(**{'sizeinbytes': 1}) 
 569          self.__field_dom.readfrombuffer(buf) 
 570          self.__field_alarm=UINT(**{'sizeinbytes': 4}) 
 571          self.__field_alarm.readfrombuffer(buf) 
 572          self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1}) 
 573          self.__field_pad3.readfrombuffer(buf) 
 574          self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 
 575          self.__field_serial.readfrombuffer(buf) 
 576          self.__field_pad4=UNKNOWN(**{'sizeinbytes': 3}) 
 577          self.__field_pad4.readfrombuffer(buf) 
 578          self.__field_ringtone=UINT(**{'sizeinbytes': 2}) 
 579          self.__field_ringtone.readfrombuffer(buf) 
 580          self._bufferendoffset=buf.getcurrentoffset() 
 581   
 582   
 583 -    def __getfield_slot(self): 
 584          return self.__field_slot.getvalue() 
 585   
 586 -    def __setfield_slot(self, value): 
 587          if isinstance(value,UINT): 
 588              self.__field_slot=value 
 589          else: 
 590              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
 591   
 592 -    def __delfield_slot(self): del self.__field_slot 
 593   
 594      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
 595   
 596 -    def __getfield_eventname(self): 
 597          return self.__field_eventname.getvalue() 
 598   
 599 -    def __setfield_eventname(self, value): 
 600          if isinstance(value,USTRING): 
 601              self.__field_eventname=value 
 602          else: 
 603              self.__field_eventname=USTRING(value,**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
 604   
 605 -    def __delfield_eventname(self): del self.__field_eventname 
 606   
 607      eventname=property(__getfield_eventname, __setfield_eventname, __delfield_eventname, None) 
 608   
 609 -    def __getfield_pad1(self): 
 610          try: self.__field_pad1 
 611          except: 
 612              self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7}) 
 613          return self.__field_pad1.getvalue() 
 614   
 615 -    def __setfield_pad1(self, value): 
 616          if isinstance(value,UNKNOWN): 
 617              self.__field_pad1=value 
 618          else: 
 619              self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 7}) 
 620   
 621 -    def __delfield_pad1(self): del self.__field_pad1 
 622   
 623      pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None) 
 624   
 625 -    def __getfield_eventname_len(self): 
 626          return self.__field_eventname_len.getvalue() 
 627   
 628 -    def __setfield_eventname_len(self, value): 
 629          if isinstance(value,UINT): 
 630              self.__field_eventname_len=value 
 631          else: 
 632              self.__field_eventname_len=UINT(value,**{'sizeinbytes': 1}) 
 633   
 634 -    def __delfield_eventname_len(self): del self.__field_eventname_len 
 635   
 636      eventname_len=property(__getfield_eventname_len, __setfield_eventname_len, __delfield_eventname_len, None) 
 637   
 638 -    def __getfield_start(self): 
 639          return self.__field_start.getvalue() 
 640   
 641 -    def __setfield_start(self, value): 
 642          if isinstance(value,UINT): 
 643              self.__field_start=value 
 644          else: 
 645              self.__field_start=UINT(value,**{'sizeinbytes': 4}) 
 646   
 647 -    def __delfield_start(self): del self.__field_start 
 648   
 649      start=property(__getfield_start, __setfield_start, __delfield_start, "# seconds since Jan 1, 1980 approximately") 
 650   
 651 -    def __getfield_end(self): 
 652          return self.__field_end.getvalue() 
 653   
 654 -    def __setfield_end(self, value): 
 655          if isinstance(value,UINT): 
 656              self.__field_end=value 
 657          else: 
 658              self.__field_end=UINT(value,**{'sizeinbytes': 4}) 
 659   
 660 -    def __delfield_end(self): del self.__field_end 
 661   
 662      end=property(__getfield_end, __setfield_end, __delfield_end, None) 
 663   
 664 -    def __getfield_location(self): 
 665          return self.__field_location.getvalue() 
 666   
 667 -    def __setfield_location(self, value): 
 668          if isinstance(value,USTRING): 
 669              self.__field_location=value 
 670          else: 
 671              self.__field_location=USTRING(value,**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
 672   
 673 -    def __delfield_location(self): del self.__field_location 
 674   
 675      location=property(__getfield_location, __setfield_location, __delfield_location, None) 
 676   
 677 -    def __getfield_pad2(self): 
 678          try: self.__field_pad2 
 679          except: 
 680              self.__field_pad2=UNKNOWN(**{'sizeinbytes': 7}) 
 681          return self.__field_pad2.getvalue() 
 682   
 683 -    def __setfield_pad2(self, value): 
 684          if isinstance(value,UNKNOWN): 
 685              self.__field_pad2=value 
 686          else: 
 687              self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 7}) 
 688   
 689 -    def __delfield_pad2(self): del self.__field_pad2 
 690   
 691      pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None) 
 692   
 693 -    def __getfield_location_len(self): 
 694          return self.__field_location_len.getvalue() 
 695   
 696 -    def __setfield_location_len(self, value): 
 697          if isinstance(value,UINT): 
 698              self.__field_location_len=value 
 699          else: 
 700              self.__field_location_len=UINT(value,**{'sizeinbytes': 1}) 
 701   
 702 -    def __delfield_location_len(self): del self.__field_location_len 
 703   
 704      location_len=property(__getfield_location_len, __setfield_location_len, __delfield_location_len, None) 
 705   
 706 -    def __getfield_alarmdiff(self): 
 707          return self.__field_alarmdiff.getvalue() 
 708   
 709 -    def __setfield_alarmdiff(self, value): 
 710          if isinstance(value,UINT): 
 711              self.__field_alarmdiff=value 
 712          else: 
 713              self.__field_alarmdiff=UINT(value,**{'sizeinbytes': 4}) 
 714   
 715 -    def __delfield_alarmdiff(self): del self.__field_alarmdiff 
 716   
 717      alarmdiff=property(__getfield_alarmdiff, __setfield_alarmdiff, __delfield_alarmdiff, "Displayed alarm time") 
 718   
 719 -    def __getfield_period(self): 
 720          return self.__field_period.getvalue() 
 721   
 722 -    def __setfield_period(self, value): 
 723          if isinstance(value,UINT): 
 724              self.__field_period=value 
 725          else: 
 726              self.__field_period=UINT(value,**{'sizeinbytes': 1}) 
 727   
 728 -    def __delfield_period(self): del self.__field_period 
 729   
 730      period=property(__getfield_period, __setfield_period, __delfield_period, "No, Daily, Weekly, Monthly, Yearly") 
 731   
 732 -    def __getfield_dom(self): 
 733          return self.__field_dom.getvalue() 
 734   
 735 -    def __setfield_dom(self, value): 
 736          if isinstance(value,UINT): 
 737              self.__field_dom=value 
 738          else: 
 739              self.__field_dom=UINT(value,**{'sizeinbytes': 1}) 
 740   
 741 -    def __delfield_dom(self): del self.__field_dom 
 742   
 743      dom=property(__getfield_dom, __setfield_dom, __delfield_dom, "Day of month for the event") 
 744   
 745 -    def __getfield_alarm(self): 
 746          return self.__field_alarm.getvalue() 
 747   
 748 -    def __setfield_alarm(self, value): 
 749          if isinstance(value,UINT): 
 750              self.__field_alarm=value 
 751          else: 
 752              self.__field_alarm=UINT(value,**{'sizeinbytes': 4}) 
 753   
 754 -    def __delfield_alarm(self): del self.__field_alarm 
 755   
 756      alarm=property(__getfield_alarm, __setfield_alarm, __delfield_alarm, None) 
 757   
 758 -    def __getfield_pad3(self): 
 759          try: self.__field_pad3 
 760          except: 
 761              self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1}) 
 762          return self.__field_pad3.getvalue() 
 763   
 764 -    def __setfield_pad3(self, value): 
 765          if isinstance(value,UNKNOWN): 
 766              self.__field_pad3=value 
 767          else: 
 768              self.__field_pad3=UNKNOWN(value,**{'sizeinbytes': 1}) 
 769   
 770 -    def __delfield_pad3(self): del self.__field_pad3 
 771   
 772      pad3=property(__getfield_pad3, __setfield_pad3, __delfield_pad3, None) 
 773   
 774 -    def __getfield_serial(self): 
 775          try: self.__field_serial 
 776          except: 
 777              self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 
 778          return self.__field_serial.getvalue() 
 779   
 780 -    def __setfield_serial(self, value): 
 781          if isinstance(value,UINT): 
 782              self.__field_serial=value 
 783          else: 
 784              self.__field_serial=UINT(value,**{'sizeinbytes': 1, 'default': 0}) 
 785   
 786 -    def __delfield_serial(self): del self.__field_serial 
 787   
 788      serial=property(__getfield_serial, __setfield_serial, __delfield_serial, "Some kind of serial number") 
 789   
 790 -    def __getfield_pad4(self): 
 791          try: self.__field_pad4 
 792          except: 
 793              self.__field_pad4=UNKNOWN(**{'sizeinbytes': 3}) 
 794          return self.__field_pad4.getvalue() 
 795   
 796 -    def __setfield_pad4(self, value): 
 797          if isinstance(value,UNKNOWN): 
 798              self.__field_pad4=value 
 799          else: 
 800              self.__field_pad4=UNKNOWN(value,**{'sizeinbytes': 3}) 
 801   
 802 -    def __delfield_pad4(self): del self.__field_pad4 
 803   
 804      pad4=property(__getfield_pad4, __setfield_pad4, __delfield_pad4, None) 
 805   
 806 -    def __getfield_ringtone(self): 
 807          return self.__field_ringtone.getvalue() 
 808   
 809 -    def __setfield_ringtone(self, value): 
 810          if isinstance(value,UINT): 
 811              self.__field_ringtone=value 
 812          else: 
 813              self.__field_ringtone=UINT(value,**{'sizeinbytes': 2}) 
 814   
 815 -    def __delfield_ringtone(self): del self.__field_ringtone 
 816   
 817      ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 
 818   
 819 -    def iscontainer(self): 
 820          return True 
 821   
 822 -    def containerelements(self): 
 823          yield ('slot', self.__field_slot, None) 
 824          yield ('eventname', self.__field_eventname, None) 
 825          yield ('pad1', self.__field_pad1, None) 
 826          yield ('eventname_len', self.__field_eventname_len, None) 
 827          yield ('start', self.__field_start, "# seconds since Jan 1, 1980 approximately") 
 828          yield ('end', self.__field_end, None) 
 829          yield ('location', self.__field_location, None) 
 830          yield ('pad2', self.__field_pad2, None) 
 831          yield ('location_len', self.__field_location_len, None) 
 832          yield ('alarmdiff', self.__field_alarmdiff, "Displayed alarm time") 
 833          yield ('period', self.__field_period, "No, Daily, Weekly, Monthly, Yearly") 
 834          yield ('dom', self.__field_dom, "Day of month for the event") 
 835          yield ('alarm', self.__field_alarm, None) 
 836          yield ('pad3', self.__field_pad3, None) 
 837          yield ('serial', self.__field_serial, "Some kind of serial number") 
 838          yield ('pad4', self.__field_pad4, None) 
 839          yield ('ringtone', self.__field_ringtone, None) 
 840   
 841   
 842   
 843   
 844 -class eventresponse(BaseProtogenClass): 
 845      __fields=['header', 'entry', 'pad'] 
 846   
 847 -    def __init__(self, *args, **kwargs): 
 848          dict={} 
 849          # What was supplied to this function 
 850          dict.update(kwargs) 
 851          # Parent constructor 
 852          super(eventresponse,self).__init__(**dict) 
 853          if self.__class__ is eventresponse: 
 854              self._update(args,dict) 
 855   
 856   
 857 -    def getfields(self): 
 858          return self.__fields 
 859   
 860   
 861 -    def _update(self, args, kwargs): 
 862          super(eventresponse,self)._update(args,kwargs) 
 863          keys=kwargs.keys() 
 864          for key in keys: 
 865              if key in self.__fields: 
 866                  setattr(self, key, kwargs[key]) 
 867                  del kwargs[key] 
 868          # Were any unrecognized kwargs passed in? 
 869          if __debug__: 
 870              self._complainaboutunusedargs(eventresponse,kwargs) 
 871          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 872          # Make all P fields that haven't already been constructed 
 873   
 874   
 875 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 876          'Writes this packet to the supplied buffer' 
 877          self._bufferstartoffset=buf.getcurrentoffset() 
 878          self.__field_header.writetobuffer(buf) 
 879          self.__field_entry.writetobuffer(buf) 
 880          self.__field_pad.writetobuffer(buf) 
 881          self._bufferendoffset=buf.getcurrentoffset() 
 882          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 883   
 884   
 885 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 886          'Reads this packet from the supplied buffer' 
 887          self._bufferstartoffset=buf.getcurrentoffset() 
 888          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 889          self.__field_header=qcpheader() 
 890          self.__field_header.readfrombuffer(buf) 
 891          self.__field_entry=evententry() 
 892          self.__field_entry.readfrombuffer(buf) 
 893          self.__field_pad=UNKNOWN() 
 894          self.__field_pad.readfrombuffer(buf) 
 895          self._bufferendoffset=buf.getcurrentoffset() 
 896   
 897   
 898 -    def __getfield_header(self): 
 899          return self.__field_header.getvalue() 
 900   
 901 -    def __setfield_header(self, value): 
 902          if isinstance(value,qcpheader): 
 903              self.__field_header=value 
 904          else: 
 905              self.__field_header=qcpheader(value,) 
 906   
 907 -    def __delfield_header(self): del self.__field_header 
 908   
 909      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
 910   
 911 -    def __getfield_entry(self): 
 912          return self.__field_entry.getvalue() 
 913   
 914 -    def __setfield_entry(self, value): 
 915          if isinstance(value,evententry): 
 916              self.__field_entry=value 
 917          else: 
 918              self.__field_entry=evententry(value,) 
 919   
 920 -    def __delfield_entry(self): del self.__field_entry 
 921   
 922      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
 923   
 924 -    def __getfield_pad(self): 
 925          return self.__field_pad.getvalue() 
 926   
 927 -    def __setfield_pad(self, value): 
 928          if isinstance(value,UNKNOWN): 
 929              self.__field_pad=value 
 930          else: 
 931              self.__field_pad=UNKNOWN(value,) 
 932   
 933 -    def __delfield_pad(self): del self.__field_pad 
 934   
 935      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
 936   
 937 -    def iscontainer(self): 
 938          return True 
 939   
 940 -    def containerelements(self): 
 941          yield ('header', self.__field_header, None) 
 942          yield ('entry', self.__field_entry, None) 
 943          yield ('pad', self.__field_pad, None) 
 944   
 945   
 946   
 947   
 948 -class eventslotinuseresponse(BaseProtogenClass): 
 949      __fields=['header', 'slot', 'flag', 'pad'] 
 950   
 951 -    def __init__(self, *args, **kwargs): 
 952          dict={} 
 953          # What was supplied to this function 
 954          dict.update(kwargs) 
 955          # Parent constructor 
 956          super(eventslotinuseresponse,self).__init__(**dict) 
 957          if self.__class__ is eventslotinuseresponse: 
 958              self._update(args,dict) 
 959   
 960   
 961 -    def getfields(self): 
 962          return self.__fields 
 963   
 964   
 965 -    def _update(self, args, kwargs): 
 966          super(eventslotinuseresponse,self)._update(args,kwargs) 
 967          keys=kwargs.keys() 
 968          for key in keys: 
 969              if key in self.__fields: 
 970                  setattr(self, key, kwargs[key]) 
 971                  del kwargs[key] 
 972          # Were any unrecognized kwargs passed in? 
 973          if __debug__: 
 974              self._complainaboutunusedargs(eventslotinuseresponse,kwargs) 
 975          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 976          # Make all P fields that haven't already been constructed 
 977   
 978   
 979 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 980          'Writes this packet to the supplied buffer' 
 981          self._bufferstartoffset=buf.getcurrentoffset() 
 982          self.__field_header.writetobuffer(buf) 
 983          self.__field_slot.writetobuffer(buf) 
 984          self.__field_flag.writetobuffer(buf) 
 985          self.__field_pad.writetobuffer(buf) 
 986          self._bufferendoffset=buf.getcurrentoffset() 
 987          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 988   
 989   
 990 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 991          'Reads this packet from the supplied buffer' 
 992          self._bufferstartoffset=buf.getcurrentoffset() 
 993          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 994          self.__field_header=qcpheader() 
 995          self.__field_header.readfrombuffer(buf) 
 996          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
 997          self.__field_slot.readfrombuffer(buf) 
 998          self.__field_flag=UINT(**{'sizeinbytes': 1}) 
 999          self.__field_flag.readfrombuffer(buf) 
1000          self.__field_pad=UNKNOWN() 
1001          self.__field_pad.readfrombuffer(buf) 
1002          self._bufferendoffset=buf.getcurrentoffset() 
1003   
1004   
1005 -    def __getfield_header(self): 
1006          return self.__field_header.getvalue() 
1007   
1008 -    def __setfield_header(self, value): 
1009          if isinstance(value,qcpheader): 
1010              self.__field_header=value 
1011          else: 
1012              self.__field_header=qcpheader(value,) 
1013   
1014 -    def __delfield_header(self): del self.__field_header 
1015   
1016      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
1017   
1018 -    def __getfield_slot(self): 
1019          return self.__field_slot.getvalue() 
1020   
1021 -    def __setfield_slot(self, value): 
1022          if isinstance(value,UINT): 
1023              self.__field_slot=value 
1024          else: 
1025              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
1026   
1027 -    def __delfield_slot(self): del self.__field_slot 
1028   
1029      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
1030   
1031 -    def __getfield_flag(self): 
1032          return self.__field_flag.getvalue() 
1033   
1034 -    def __setfield_flag(self, value): 
1035          if isinstance(value,UINT): 
1036              self.__field_flag=value 
1037          else: 
1038              self.__field_flag=UINT(value,**{'sizeinbytes': 1}) 
1039   
1040 -    def __delfield_flag(self): del self.__field_flag 
1041   
1042      flag=property(__getfield_flag, __setfield_flag, __delfield_flag, None) 
1043   
1044 -    def __getfield_pad(self): 
1045          return self.__field_pad.getvalue() 
1046   
1047 -    def __setfield_pad(self, value): 
1048          if isinstance(value,UNKNOWN): 
1049              self.__field_pad=value 
1050          else: 
1051              self.__field_pad=UNKNOWN(value,) 
1052   
1053 -    def __delfield_pad(self): del self.__field_pad 
1054   
1055      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
1056   
1057 -    def iscontainer(self): 
1058          return True 
1059   
1060 -    def containerelements(self): 
1061          yield ('header', self.__field_header, None) 
1062          yield ('slot', self.__field_slot, None) 
1063          yield ('flag', self.__field_flag, None) 
1064          yield ('pad', self.__field_pad, None) 
1065   
1066   
1067   
1068   
1069 -class eventslotinuseupdaterequest(BaseProtogenClass): 
1070      __fields=['header', 'slot', 'flag', 'pad'] 
1071   
1072 -    def __init__(self, *args, **kwargs): 
1073          dict={} 
1074          # What was supplied to this function 
1075          dict.update(kwargs) 
1076          # Parent constructor 
1077          super(eventslotinuseupdaterequest,self).__init__(**dict) 
1078          if self.__class__ is eventslotinuseupdaterequest: 
1079              self._update(args,dict) 
1080   
1081   
1082 -    def getfields(self): 
1083          return self.__fields 
1084   
1085   
1086 -    def _update(self, args, kwargs): 
1087          super(eventslotinuseupdaterequest,self)._update(args,kwargs) 
1088          keys=kwargs.keys() 
1089          for key in keys: 
1090              if key in self.__fields: 
1091                  setattr(self, key, kwargs[key]) 
1092                  del kwargs[key] 
1093          # Were any unrecognized kwargs passed in? 
1094          if __debug__: 
1095              self._complainaboutunusedargs(eventslotinuseupdaterequest,kwargs) 
1096          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1097          # Make all P fields that haven't already been constructed 
1098   
1099   
1100 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1101          'Writes this packet to the supplied buffer' 
1102          self._bufferstartoffset=buf.getcurrentoffset() 
1103          try: self.__field_header 
1104          except: 
1105              self.__field_header=qcpwriteheader(**{'packettype': 0x0d, 'command': 0x74}) 
1106          self.__field_header.writetobuffer(buf) 
1107          self.__field_slot.writetobuffer(buf) 
1108          self.__field_flag.writetobuffer(buf) 
1109          try: self.__field_pad 
1110          except: 
1111              self.__field_pad=UNKNOWN(**{'sizeinbytes': 124}) 
1112          self.__field_pad.writetobuffer(buf) 
1113          self._bufferendoffset=buf.getcurrentoffset() 
1114          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1115   
1116   
1117 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1118          'Reads this packet from the supplied buffer' 
1119          self._bufferstartoffset=buf.getcurrentoffset() 
1120          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1121          self.__field_header=qcpwriteheader(**{'packettype': 0x0d, 'command': 0x74}) 
1122          self.__field_header.readfrombuffer(buf) 
1123          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
1124          self.__field_slot.readfrombuffer(buf) 
1125          self.__field_flag=UINT(**{'sizeinbytes': 1}) 
1126          self.__field_flag.readfrombuffer(buf) 
1127          self.__field_pad=UNKNOWN(**{'sizeinbytes': 124}) 
1128          self.__field_pad.readfrombuffer(buf) 
1129          self._bufferendoffset=buf.getcurrentoffset() 
1130   
1131   
1132 -    def __getfield_header(self): 
1133          try: self.__field_header 
1134          except: 
1135              self.__field_header=qcpwriteheader(**{'packettype': 0x0d, 'command': 0x74}) 
1136          return self.__field_header.getvalue() 
1137   
1138 -    def __setfield_header(self, value): 
1139          if isinstance(value,qcpwriteheader): 
1140              self.__field_header=value 
1141          else: 
1142              self.__field_header=qcpwriteheader(value,**{'packettype': 0x0d, 'command': 0x74}) 
1143   
1144 -    def __delfield_header(self): del self.__field_header 
1145   
1146      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
1147   
1148 -    def __getfield_slot(self): 
1149          return self.__field_slot.getvalue() 
1150   
1151 -    def __setfield_slot(self, value): 
1152          if isinstance(value,UINT): 
1153              self.__field_slot=value 
1154          else: 
1155              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
1156   
1157 -    def __delfield_slot(self): del self.__field_slot 
1158   
1159      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
1160   
1161 -    def __getfield_flag(self): 
1162          return self.__field_flag.getvalue() 
1163   
1164 -    def __setfield_flag(self, value): 
1165          if isinstance(value,UINT): 
1166              self.__field_flag=value 
1167          else: 
1168              self.__field_flag=UINT(value,**{'sizeinbytes': 1}) 
1169   
1170 -    def __delfield_flag(self): del self.__field_flag 
1171   
1172      flag=property(__getfield_flag, __setfield_flag, __delfield_flag, None) 
1173   
1174 -    def __getfield_pad(self): 
1175          try: self.__field_pad 
1176          except: 
1177              self.__field_pad=UNKNOWN(**{'sizeinbytes': 124}) 
1178          return self.__field_pad.getvalue() 
1179   
1180 -    def __setfield_pad(self, value): 
1181          if isinstance(value,UNKNOWN): 
1182              self.__field_pad=value 
1183          else: 
1184              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 124}) 
1185   
1186 -    def __delfield_pad(self): del self.__field_pad 
1187   
1188      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
1189   
1190 -    def iscontainer(self): 
1191          return True 
1192   
1193 -    def containerelements(self): 
1194          yield ('header', self.__field_header, None) 
1195          yield ('slot', self.__field_slot, None) 
1196          yield ('flag', self.__field_flag, None) 
1197          yield ('pad', self.__field_pad, None) 
1198   
1199   
1200   
1201   
1202 -class eventupdaterequest(BaseProtogenClass): 
1203      __fields=['header', 'entry', 'pad'] 
1204   
1205 -    def __init__(self, *args, **kwargs): 
1206          dict={} 
1207          # What was supplied to this function 
1208          dict.update(kwargs) 
1209          # Parent constructor 
1210          super(eventupdaterequest,self).__init__(**dict) 
1211          if self.__class__ is eventupdaterequest: 
1212              self._update(args,dict) 
1213   
1214   
1215 -    def getfields(self): 
1216          return self.__fields 
1217   
1218   
1219 -    def _update(self, args, kwargs): 
1220          super(eventupdaterequest,self)._update(args,kwargs) 
1221          keys=kwargs.keys() 
1222          for key in keys: 
1223              if key in self.__fields: 
1224                  setattr(self, key, kwargs[key]) 
1225                  del kwargs[key] 
1226          # Were any unrecognized kwargs passed in? 
1227          if __debug__: 
1228              self._complainaboutunusedargs(eventupdaterequest,kwargs) 
1229          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1230          # Make all P fields that haven't already been constructed 
1231   
1232   
1233 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1234          'Writes this packet to the supplied buffer' 
1235          self._bufferstartoffset=buf.getcurrentoffset() 
1236          try: self.__field_header 
1237          except: 
1238              self.__field_header=qcpwriteheader(**{'packettype': 0x0c, 'command':0x23}) 
1239          self.__field_header.writetobuffer(buf) 
1240          self.__field_entry.writetobuffer(buf) 
1241          try: self.__field_pad 
1242          except: 
1243              self.__field_pad=UNKNOWN(**{'sizeinbytes': 56}) 
1244          self.__field_pad.writetobuffer(buf) 
1245          self._bufferendoffset=buf.getcurrentoffset() 
1246          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1247   
1248   
1249 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1250          'Reads this packet from the supplied buffer' 
1251          self._bufferstartoffset=buf.getcurrentoffset() 
1252          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1253          self.__field_header=qcpwriteheader(**{'packettype': 0x0c, 'command':0x23}) 
1254          self.__field_header.readfrombuffer(buf) 
1255          self.__field_entry=evententry() 
1256          self.__field_entry.readfrombuffer(buf) 
1257          self.__field_pad=UNKNOWN(**{'sizeinbytes': 56}) 
1258          self.__field_pad.readfrombuffer(buf) 
1259          self._bufferendoffset=buf.getcurrentoffset() 
1260   
1261   
1262 -    def __getfield_header(self): 
1263          try: self.__field_header 
1264          except: 
1265              self.__field_header=qcpwriteheader(**{'packettype': 0x0c, 'command':0x23}) 
1266          return self.__field_header.getvalue() 
1267   
1268 -    def __setfield_header(self, value): 
1269          if isinstance(value,qcpwriteheader): 
1270              self.__field_header=value 
1271          else: 
1272              self.__field_header=qcpwriteheader(value,**{'packettype': 0x0c, 'command':0x23}) 
1273   
1274 -    def __delfield_header(self): del self.__field_header 
1275   
1276      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
1277   
1278 -    def __getfield_entry(self): 
1279          return self.__field_entry.getvalue() 
1280   
1281 -    def __setfield_entry(self, value): 
1282          if isinstance(value,evententry): 
1283              self.__field_entry=value 
1284          else: 
1285              self.__field_entry=evententry(value,) 
1286   
1287 -    def __delfield_entry(self): del self.__field_entry 
1288   
1289      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
1290   
1291 -    def __getfield_pad(self): 
1292          try: self.__field_pad 
1293          except: 
1294              self.__field_pad=UNKNOWN(**{'sizeinbytes': 56}) 
1295          return self.__field_pad.getvalue() 
1296   
1297 -    def __setfield_pad(self, value): 
1298          if isinstance(value,UNKNOWN): 
1299              self.__field_pad=value 
1300          else: 
1301              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 56}) 
1302   
1303 -    def __delfield_pad(self): del self.__field_pad 
1304   
1305      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
1306   
1307 -    def iscontainer(self): 
1308          return True 
1309   
1310 -    def containerelements(self): 
1311          yield ('header', self.__field_header, None) 
1312          yield ('entry', self.__field_entry, None) 
1313          yield ('pad', self.__field_pad, None) 
1314   
1315   
1316   
1317   
1318 -class callalarmrequest(BaseProtogenClass): 
1319      __fields=['header', 'slot', 'pad'] 
1320   
1321 -    def __init__(self, *args, **kwargs): 
1322          dict={} 
1323          # What was supplied to this function 
1324          dict.update(kwargs) 
1325          # Parent constructor 
1326          super(callalarmrequest,self).__init__(**dict) 
1327          if self.__class__ is callalarmrequest: 
1328              self._update(args,dict) 
1329   
1330   
1331 -    def getfields(self): 
1332          return self.__fields 
1333   
1334   
1335 -    def _update(self, args, kwargs): 
1336          super(callalarmrequest,self)._update(args,kwargs) 
1337          keys=kwargs.keys() 
1338          for key in keys: 
1339              if key in self.__fields: 
1340                  setattr(self, key, kwargs[key]) 
1341                  del kwargs[key] 
1342          # Were any unrecognized kwargs passed in? 
1343          if __debug__: 
1344              self._complainaboutunusedargs(callalarmrequest,kwargs) 
1345          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1346          # Make all P fields that haven't already been constructed 
1347   
1348   
1349 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1350          'Writes this packet to the supplied buffer' 
1351          self._bufferstartoffset=buf.getcurrentoffset() 
1352          try: self.__field_header 
1353          except: 
1354              self.__field_header=qcpheader(**{'packettype': 0x0c, 'command': 0x24}) 
1355          self.__field_header.writetobuffer(buf) 
1356          self.__field_slot.writetobuffer(buf) 
1357          try: self.__field_pad 
1358          except: 
1359              self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 
1360          self.__field_pad.writetobuffer(buf) 
1361          self._bufferendoffset=buf.getcurrentoffset() 
1362          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1363   
1364   
1365 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1366          'Reads this packet from the supplied buffer' 
1367          self._bufferstartoffset=buf.getcurrentoffset() 
1368          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1369          self.__field_header=qcpheader(**{'packettype': 0x0c, 'command': 0x24}) 
1370          self.__field_header.readfrombuffer(buf) 
1371          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
1372          self.__field_slot.readfrombuffer(buf) 
1373          self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 
1374          self.__field_pad.readfrombuffer(buf) 
1375          self._bufferendoffset=buf.getcurrentoffset() 
1376   
1377   
1378 -    def __getfield_header(self): 
1379          try: self.__field_header 
1380          except: 
1381              self.__field_header=qcpheader(**{'packettype': 0x0c, 'command': 0x24}) 
1382          return self.__field_header.getvalue() 
1383   
1384 -    def __setfield_header(self, value): 
1385          if isinstance(value,qcpheader): 
1386              self.__field_header=value 
1387          else: 
1388              self.__field_header=qcpheader(value,**{'packettype': 0x0c, 'command': 0x24}) 
1389   
1390 -    def __delfield_header(self): del self.__field_header 
1391   
1392      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
1393   
1394 -    def __getfield_slot(self): 
1395          return self.__field_slot.getvalue() 
1396   
1397 -    def __setfield_slot(self, value): 
1398          if isinstance(value,UINT): 
1399              self.__field_slot=value 
1400          else: 
1401              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
1402   
1403 -    def __delfield_slot(self): del self.__field_slot 
1404   
1405      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
1406   
1407 -    def __getfield_pad(self): 
1408          try: self.__field_pad 
1409          except: 
1410              self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 
1411          return self.__field_pad.getvalue() 
1412   
1413 -    def __setfield_pad(self, value): 
1414          if isinstance(value,UNKNOWN): 
1415              self.__field_pad=value 
1416          else: 
1417              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 129}) 
1418   
1419 -    def __delfield_pad(self): del self.__field_pad 
1420   
1421      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
1422   
1423 -    def iscontainer(self): 
1424          return True 
1425   
1426 -    def containerelements(self): 
1427          yield ('header', self.__field_header, None) 
1428          yield ('slot', self.__field_slot, None) 
1429          yield ('pad', self.__field_pad, None) 
1430   
1431   
1432   
1433   
1434 -class callalarmresponse(BaseProtogenClass): 
1435      __fields=['header', 'entry', 'pad'] 
1436   
1437 -    def __init__(self, *args, **kwargs): 
1438          dict={} 
1439          # What was supplied to this function 
1440          dict.update(kwargs) 
1441          # Parent constructor 
1442          super(callalarmresponse,self).__init__(**dict) 
1443          if self.__class__ is callalarmresponse: 
1444              self._update(args,dict) 
1445   
1446   
1447 -    def getfields(self): 
1448          return self.__fields 
1449   
1450   
1451 -    def _update(self, args, kwargs): 
1452          super(callalarmresponse,self)._update(args,kwargs) 
1453          keys=kwargs.keys() 
1454          for key in keys: 
1455              if key in self.__fields: 
1456                  setattr(self, key, kwargs[key]) 
1457                  del kwargs[key] 
1458          # Were any unrecognized kwargs passed in? 
1459          if __debug__: 
1460              self._complainaboutunusedargs(callalarmresponse,kwargs) 
1461          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1462          # Make all P fields that haven't already been constructed 
1463   
1464   
1465 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1466          'Writes this packet to the supplied buffer' 
1467          self._bufferstartoffset=buf.getcurrentoffset() 
1468          self.__field_header.writetobuffer(buf) 
1469          self.__field_entry.writetobuffer(buf) 
1470          self.__field_pad.writetobuffer(buf) 
1471          self._bufferendoffset=buf.getcurrentoffset() 
1472          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1473   
1474   
1475 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1476          'Reads this packet from the supplied buffer' 
1477          self._bufferstartoffset=buf.getcurrentoffset() 
1478          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1479          self.__field_header=qcpheader() 
1480          self.__field_header.readfrombuffer(buf) 
1481          self.__field_entry=callalarmentry() 
1482          self.__field_entry.readfrombuffer(buf) 
1483          self.__field_pad=UNKNOWN() 
1484          self.__field_pad.readfrombuffer(buf) 
1485          self._bufferendoffset=buf.getcurrentoffset() 
1486   
1487   
1488 -    def __getfield_header(self): 
1489          return self.__field_header.getvalue() 
1490   
1491 -    def __setfield_header(self, value): 
1492          if isinstance(value,qcpheader): 
1493              self.__field_header=value 
1494          else: 
1495              self.__field_header=qcpheader(value,) 
1496   
1497 -    def __delfield_header(self): del self.__field_header 
1498   
1499      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
1500   
1501 -    def __getfield_entry(self): 
1502          return self.__field_entry.getvalue() 
1503   
1504 -    def __setfield_entry(self, value): 
1505          if isinstance(value,callalarmentry): 
1506              self.__field_entry=value 
1507          else: 
1508              self.__field_entry=callalarmentry(value,) 
1509   
1510 -    def __delfield_entry(self): del self.__field_entry 
1511   
1512      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
1513   
1514 -    def __getfield_pad(self): 
1515          return self.__field_pad.getvalue() 
1516   
1517 -    def __setfield_pad(self, value): 
1518          if isinstance(value,UNKNOWN): 
1519              self.__field_pad=value 
1520          else: 
1521              self.__field_pad=UNKNOWN(value,) 
1522   
1523 -    def __delfield_pad(self): del self.__field_pad 
1524   
1525      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
1526   
1527 -    def iscontainer(self): 
1528          return True 
1529   
1530 -    def containerelements(self): 
1531          yield ('header', self.__field_header, None) 
1532          yield ('entry', self.__field_entry, None) 
1533          yield ('pad', self.__field_pad, None) 
1534   
1535   
1536   
1537   
1538 -class callalarmupdaterequest(BaseProtogenClass): 
1539      __fields=['header', 'entry', 'pad'] 
1540   
1541 -    def __init__(self, *args, **kwargs): 
1542          dict={} 
1543          # What was supplied to this function 
1544          dict.update(kwargs) 
1545          # Parent constructor 
1546          super(callalarmupdaterequest,self).__init__(**dict) 
1547          if self.__class__ is callalarmupdaterequest: 
1548              self._update(args,dict) 
1549   
1550   
1551 -    def getfields(self): 
1552          return self.__fields 
1553   
1554   
1555 -    def _update(self, args, kwargs): 
1556          super(callalarmupdaterequest,self)._update(args,kwargs) 
1557          keys=kwargs.keys() 
1558          for key in keys: 
1559              if key in self.__fields: 
1560                  setattr(self, key, kwargs[key]) 
1561                  del kwargs[key] 
1562          # Were any unrecognized kwargs passed in? 
1563          if __debug__: 
1564              self._complainaboutunusedargs(callalarmupdaterequest,kwargs) 
1565          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1566          # Make all P fields that haven't already been constructed 
1567   
1568   
1569 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1570          'Writes this packet to the supplied buffer' 
1571          self._bufferstartoffset=buf.getcurrentoffset() 
1572          try: self.__field_header 
1573          except: 
1574              self.__field_header=qcpwriteheader(**{'packettype': 0x0c, 'command':0x24}) 
1575          self.__field_header.writetobuffer(buf) 
1576          self.__field_entry.writetobuffer(buf) 
1577          try: self.__field_pad 
1578          except: 
1579              self.__field_pad=UNKNOWN(**{'sizeinbytes': 40}) 
1580          self.__field_pad.writetobuffer(buf) 
1581          self._bufferendoffset=buf.getcurrentoffset() 
1582          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1583   
1584   
1585 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1586          'Reads this packet from the supplied buffer' 
1587          self._bufferstartoffset=buf.getcurrentoffset() 
1588          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1589          self.__field_header=qcpwriteheader(**{'packettype': 0x0c, 'command':0x24}) 
1590          self.__field_header.readfrombuffer(buf) 
1591          self.__field_entry=callalarmentry() 
1592          self.__field_entry.readfrombuffer(buf) 
1593          self.__field_pad=UNKNOWN(**{'sizeinbytes': 40}) 
1594          self.__field_pad.readfrombuffer(buf) 
1595          self._bufferendoffset=buf.getcurrentoffset() 
1596   
1597   
1598 -    def __getfield_header(self): 
1599          try: self.__field_header 
1600          except: 
1601              self.__field_header=qcpwriteheader(**{'packettype': 0x0c, 'command':0x24}) 
1602          return self.__field_header.getvalue() 
1603   
1604 -    def __setfield_header(self, value): 
1605          if isinstance(value,qcpwriteheader): 
1606              self.__field_header=value 
1607          else: 
1608              self.__field_header=qcpwriteheader(value,**{'packettype': 0x0c, 'command':0x24}) 
1609   
1610 -    def __delfield_header(self): del self.__field_header 
1611   
1612      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
1613   
1614 -    def __getfield_entry(self): 
1615          return self.__field_entry.getvalue() 
1616   
1617 -    def __setfield_entry(self, value): 
1618          if isinstance(value,callalarmentry): 
1619              self.__field_entry=value 
1620          else: 
1621              self.__field_entry=callalarmentry(value,) 
1622   
1623 -    def __delfield_entry(self): del self.__field_entry 
1624   
1625      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
1626   
1627 -    def __getfield_pad(self): 
1628          try: self.__field_pad 
1629          except: 
1630              self.__field_pad=UNKNOWN(**{'sizeinbytes': 40}) 
1631          return self.__field_pad.getvalue() 
1632   
1633 -    def __setfield_pad(self, value): 
1634          if isinstance(value,UNKNOWN): 
1635              self.__field_pad=value 
1636          else: 
1637              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 40}) 
1638   
1639 -    def __delfield_pad(self): del self.__field_pad 
1640   
1641      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
1642   
1643 -    def iscontainer(self): 
1644          return True 
1645   
1646 -    def containerelements(self): 
1647          yield ('header', self.__field_header, None) 
1648          yield ('entry', self.__field_entry, None) 
1649          yield ('pad', self.__field_pad, None) 
1650   
1651   
1652   
1653   
1654 -class callalarmslotinuserequest(BaseProtogenClass): 
1655      __fields=['header', 'slot', 'pad'] 
1656   
1657 -    def __init__(self, *args, **kwargs): 
1658          dict={} 
1659          # What was supplied to this function 
1660          dict.update(kwargs) 
1661          # Parent constructor 
1662          super(callalarmslotinuserequest,self).__init__(**dict) 
1663          if self.__class__ is callalarmslotinuserequest: 
1664              self._update(args,dict) 
1665   
1666   
1667 -    def getfields(self): 
1668          return self.__fields 
1669   
1670   
1671 -    def _update(self, args, kwargs): 
1672          super(callalarmslotinuserequest,self)._update(args,kwargs) 
1673          keys=kwargs.keys() 
1674          for key in keys: 
1675              if key in self.__fields: 
1676                  setattr(self, key, kwargs[key]) 
1677                  del kwargs[key] 
1678          # Were any unrecognized kwargs passed in? 
1679          if __debug__: 
1680              self._complainaboutunusedargs(callalarmslotinuserequest,kwargs) 
1681          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1682          # Make all P fields that haven't already been constructed 
1683   
1684   
1685 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1686          'Writes this packet to the supplied buffer' 
1687          self._bufferstartoffset=buf.getcurrentoffset() 
1688          try: self.__field_header 
1689          except: 
1690              self.__field_header=qcpheader(**{'packettype': 0x0d, 'command': 0x76}) 
1691          self.__field_header.writetobuffer(buf) 
1692          self.__field_slot.writetobuffer(buf) 
1693          try: self.__field_pad 
1694          except: 
1695              self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 
1696          self.__field_pad.writetobuffer(buf) 
1697          self._bufferendoffset=buf.getcurrentoffset() 
1698          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1699   
1700   
1701 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1702          'Reads this packet from the supplied buffer' 
1703          self._bufferstartoffset=buf.getcurrentoffset() 
1704          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1705          self.__field_header=qcpheader(**{'packettype': 0x0d, 'command': 0x76}) 
1706          self.__field_header.readfrombuffer(buf) 
1707          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
1708          self.__field_slot.readfrombuffer(buf) 
1709          self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 
1710          self.__field_pad.readfrombuffer(buf) 
1711          self._bufferendoffset=buf.getcurrentoffset() 
1712   
1713   
1714 -    def __getfield_header(self): 
1715          try: self.__field_header 
1716          except: 
1717              self.__field_header=qcpheader(**{'packettype': 0x0d, 'command': 0x76}) 
1718          return self.__field_header.getvalue() 
1719   
1720 -    def __setfield_header(self, value): 
1721          if isinstance(value,qcpheader): 
1722              self.__field_header=value 
1723          else: 
1724              self.__field_header=qcpheader(value,**{'packettype': 0x0d, 'command': 0x76}) 
1725   
1726 -    def __delfield_header(self): del self.__field_header 
1727   
1728      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
1729   
1730 -    def __getfield_slot(self): 
1731          return self.__field_slot.getvalue() 
1732   
1733 -    def __setfield_slot(self, value): 
1734          if isinstance(value,UINT): 
1735              self.__field_slot=value 
1736          else: 
1737              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
1738   
1739 -    def __delfield_slot(self): del self.__field_slot 
1740   
1741      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
1742   
1743 -    def __getfield_pad(self): 
1744          try: self.__field_pad 
1745          except: 
1746              self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 
1747          return self.__field_pad.getvalue() 
1748   
1749 -    def __setfield_pad(self, value): 
1750          if isinstance(value,UNKNOWN): 
1751              self.__field_pad=value 
1752          else: 
1753              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 129}) 
1754   
1755 -    def __delfield_pad(self): del self.__field_pad 
1756   
1757      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
1758   
1759 -    def iscontainer(self): 
1760          return True 
1761   
1762 -    def containerelements(self): 
1763          yield ('header', self.__field_header, None) 
1764          yield ('slot', self.__field_slot, None) 
1765          yield ('pad', self.__field_pad, None) 
1766   
1767   
1768   
1769   
1770 -class callalarmslotinuseresponse(BaseProtogenClass): 
1771      __fields=['header', 'slot', 'flag', 'pad'] 
1772   
1773 -    def __init__(self, *args, **kwargs): 
1774          dict={} 
1775          # What was supplied to this function 
1776          dict.update(kwargs) 
1777          # Parent constructor 
1778          super(callalarmslotinuseresponse,self).__init__(**dict) 
1779          if self.__class__ is callalarmslotinuseresponse: 
1780              self._update(args,dict) 
1781   
1782   
1783 -    def getfields(self): 
1784          return self.__fields 
1785   
1786   
1787 -    def _update(self, args, kwargs): 
1788          super(callalarmslotinuseresponse,self)._update(args,kwargs) 
1789          keys=kwargs.keys() 
1790          for key in keys: 
1791              if key in self.__fields: 
1792                  setattr(self, key, kwargs[key]) 
1793                  del kwargs[key] 
1794          # Were any unrecognized kwargs passed in? 
1795          if __debug__: 
1796              self._complainaboutunusedargs(callalarmslotinuseresponse,kwargs) 
1797          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1798          # Make all P fields that haven't already been constructed 
1799   
1800   
1801 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1802          'Writes this packet to the supplied buffer' 
1803          self._bufferstartoffset=buf.getcurrentoffset() 
1804          self.__field_header.writetobuffer(buf) 
1805          self.__field_slot.writetobuffer(buf) 
1806          self.__field_flag.writetobuffer(buf) 
1807          self.__field_pad.writetobuffer(buf) 
1808          self._bufferendoffset=buf.getcurrentoffset() 
1809          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1810   
1811   
1812 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1813          'Reads this packet from the supplied buffer' 
1814          self._bufferstartoffset=buf.getcurrentoffset() 
1815          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1816          self.__field_header=qcpheader() 
1817          self.__field_header.readfrombuffer(buf) 
1818          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
1819          self.__field_slot.readfrombuffer(buf) 
1820          self.__field_flag=UINT(**{'sizeinbytes': 1}) 
1821          self.__field_flag.readfrombuffer(buf) 
1822          self.__field_pad=UNKNOWN() 
1823          self.__field_pad.readfrombuffer(buf) 
1824          self._bufferendoffset=buf.getcurrentoffset() 
1825   
1826   
1827 -    def __getfield_header(self): 
1828          return self.__field_header.getvalue() 
1829   
1830 -    def __setfield_header(self, value): 
1831          if isinstance(value,qcpheader): 
1832              self.__field_header=value 
1833          else: 
1834              self.__field_header=qcpheader(value,) 
1835   
1836 -    def __delfield_header(self): del self.__field_header 
1837   
1838      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
1839   
1840 -    def __getfield_slot(self): 
1841          return self.__field_slot.getvalue() 
1842   
1843 -    def __setfield_slot(self, value): 
1844          if isinstance(value,UINT): 
1845              self.__field_slot=value 
1846          else: 
1847              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
1848   
1849 -    def __delfield_slot(self): del self.__field_slot 
1850   
1851      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
1852   
1853 -    def __getfield_flag(self): 
1854          return self.__field_flag.getvalue() 
1855   
1856 -    def __setfield_flag(self, value): 
1857          if isinstance(value,UINT): 
1858              self.__field_flag=value 
1859          else: 
1860              self.__field_flag=UINT(value,**{'sizeinbytes': 1}) 
1861   
1862 -    def __delfield_flag(self): del self.__field_flag 
1863   
1864      flag=property(__getfield_flag, __setfield_flag, __delfield_flag, None) 
1865   
1866 -    def __getfield_pad(self): 
1867          return self.__field_pad.getvalue() 
1868   
1869 -    def __setfield_pad(self, value): 
1870          if isinstance(value,UNKNOWN): 
1871              self.__field_pad=value 
1872          else: 
1873              self.__field_pad=UNKNOWN(value,) 
1874   
1875 -    def __delfield_pad(self): del self.__field_pad 
1876   
1877      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
1878   
1879 -    def iscontainer(self): 
1880          return True 
1881   
1882 -    def containerelements(self): 
1883          yield ('header', self.__field_header, None) 
1884          yield ('slot', self.__field_slot, None) 
1885          yield ('flag', self.__field_flag, None) 
1886          yield ('pad', self.__field_pad, None) 
1887   
1888   
1889   
1890   
1891 -class callalarmentry(BaseProtogenClass): 
1892      __fields=['slot', 'pad0', 'phonenum', 'phonenum_len', 'date', 'period', 'dom', 'datedup', 'name', 'pad1', 'name_len', 'phonenumbertype', 'phonenumberslot', 'pad2', 'serial', 'pad3', 'ringtone', 'pad4', 'flag'] 
1893   
1894 -    def __init__(self, *args, **kwargs): 
1895          dict={} 
1896          # What was supplied to this function 
1897          dict.update(kwargs) 
1898          # Parent constructor 
1899          super(callalarmentry,self).__init__(**dict) 
1900          if self.__class__ is callalarmentry: 
1901              self._update(args,dict) 
1902   
1903   
1904 -    def getfields(self): 
1905          return self.__fields 
1906   
1907   
1908 -    def _update(self, args, kwargs): 
1909          super(callalarmentry,self)._update(args,kwargs) 
1910          keys=kwargs.keys() 
1911          for key in keys: 
1912              if key in self.__fields: 
1913                  setattr(self, key, kwargs[key]) 
1914                  del kwargs[key] 
1915          # Were any unrecognized kwargs passed in? 
1916          if __debug__: 
1917              self._complainaboutunusedargs(callalarmentry,kwargs) 
1918          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1919          # Make all P fields that haven't already been constructed 
1920   
1921   
1922 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1923          'Writes this packet to the supplied buffer' 
1924          self._bufferstartoffset=buf.getcurrentoffset() 
1925          self.__field_slot.writetobuffer(buf) 
1926          try: self.__field_pad0 
1927          except: 
1928              self.__field_pad0=UNKNOWN(**{'sizeinbytes': 1}) 
1929          self.__field_pad0.writetobuffer(buf) 
1930          self.__field_phonenum.writetobuffer(buf) 
1931          self.__field_phonenum_len.writetobuffer(buf) 
1932          self.__field_date.writetobuffer(buf) 
1933          self.__field_period.writetobuffer(buf) 
1934          self.__field_dom.writetobuffer(buf) 
1935          self.__field_datedup.writetobuffer(buf) 
1936          self.__field_name.writetobuffer(buf) 
1937          try: self.__field_pad1 
1938          except: 
1939              self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1}) 
1940          self.__field_pad1.writetobuffer(buf) 
1941          self.__field_name_len.writetobuffer(buf) 
1942          self.__field_phonenumbertype.writetobuffer(buf) 
1943          self.__field_phonenumberslot.writetobuffer(buf) 
1944          try: self.__field_pad2 
1945          except: 
1946              self.__field_pad2=UNKNOWN(**{'sizeinbytes': 1}) 
1947          self.__field_pad2.writetobuffer(buf) 
1948          try: self.__field_serial 
1949          except: 
1950              self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 
1951          self.__field_serial.writetobuffer(buf) 
1952          try: self.__field_pad3 
1953          except: 
1954              self.__field_pad3=UNKNOWN(**{'sizeinbytes': 2}) 
1955          self.__field_pad3.writetobuffer(buf) 
1956          try: self.__field_ringtone 
1957          except: 
1958              self.__field_ringtone=UINT(**{'sizeinbytes': 1, 'default': 0xfc}) 
1959          self.__field_ringtone.writetobuffer(buf) 
1960          try: self.__field_pad4 
1961          except: 
1962              self.__field_pad4=UNKNOWN(**{'sizeinbytes': 1}) 
1963          self.__field_pad4.writetobuffer(buf) 
1964          try: self.__field_flag 
1965          except: 
1966              self.__field_flag=UINT(**{'sizeinbytes': 1}) 
1967          self.__field_flag.writetobuffer(buf) 
1968          self._bufferendoffset=buf.getcurrentoffset() 
1969          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1970   
1971   
1972 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1973          'Reads this packet from the supplied buffer' 
1974          self._bufferstartoffset=buf.getcurrentoffset() 
1975          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1976          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
1977          self.__field_slot.readfrombuffer(buf) 
1978          self.__field_pad0=UNKNOWN(**{'sizeinbytes': 1}) 
1979          self.__field_pad0.readfrombuffer(buf) 
1980          self.__field_phonenum=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 
1981          self.__field_phonenum.readfrombuffer(buf) 
1982          self.__field_phonenum_len=UINT(**{'sizeinbytes': 1}) 
1983          self.__field_phonenum_len.readfrombuffer(buf) 
1984          self.__field_date=UINT(**{'sizeinbytes': 4}) 
1985          self.__field_date.readfrombuffer(buf) 
1986          self.__field_period=UINT(**{'sizeinbytes': 1}) 
1987          self.__field_period.readfrombuffer(buf) 
1988          self.__field_dom=UINT(**{'sizeinbytes': 1}) 
1989          self.__field_dom.readfrombuffer(buf) 
1990          self.__field_datedup=UINT(**{'sizeinbytes': 4}) 
1991          self.__field_datedup.readfrombuffer(buf) 
1992          self.__field_name=USTRING(**{'sizeinbytes': 16, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
1993          self.__field_name.readfrombuffer(buf) 
1994          self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1}) 
1995          self.__field_pad1.readfrombuffer(buf) 
1996          self.__field_name_len=UINT(**{'sizeinbytes': 1}) 
1997          self.__field_name_len.readfrombuffer(buf) 
1998          self.__field_phonenumbertype=UINT(**{'sizeinbytes': 1}) 
1999          self.__field_phonenumbertype.readfrombuffer(buf) 
2000          self.__field_phonenumberslot=UINT(**{'sizeinbytes': 2}) 
2001          self.__field_phonenumberslot.readfrombuffer(buf) 
2002          self.__field_pad2=UNKNOWN(**{'sizeinbytes': 1}) 
2003          self.__field_pad2.readfrombuffer(buf) 
2004          self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 
2005          self.__field_serial.readfrombuffer(buf) 
2006          self.__field_pad3=UNKNOWN(**{'sizeinbytes': 2}) 
2007          self.__field_pad3.readfrombuffer(buf) 
2008          self.__field_ringtone=UINT(**{'sizeinbytes': 1, 'default': 0xfc}) 
2009          self.__field_ringtone.readfrombuffer(buf) 
2010          self.__field_pad4=UNKNOWN(**{'sizeinbytes': 1}) 
2011          self.__field_pad4.readfrombuffer(buf) 
2012          self.__field_flag=UINT(**{'sizeinbytes': 1}) 
2013          self.__field_flag.readfrombuffer(buf) 
2014          self._bufferendoffset=buf.getcurrentoffset() 
2015   
2016   
2017 -    def __getfield_slot(self): 
2018          return self.__field_slot.getvalue() 
2019   
2020 -    def __setfield_slot(self, value): 
2021          if isinstance(value,UINT): 
2022              self.__field_slot=value 
2023          else: 
2024              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
2025   
2026 -    def __delfield_slot(self): del self.__field_slot 
2027   
2028      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
2029   
2030 -    def __getfield_pad0(self): 
2031          try: self.__field_pad0 
2032          except: 
2033              self.__field_pad0=UNKNOWN(**{'sizeinbytes': 1}) 
2034          return self.__field_pad0.getvalue() 
2035   
2036 -    def __setfield_pad0(self, value): 
2037          if isinstance(value,UNKNOWN): 
2038              self.__field_pad0=value 
2039          else: 
2040              self.__field_pad0=UNKNOWN(value,**{'sizeinbytes': 1}) 
2041   
2042 -    def __delfield_pad0(self): del self.__field_pad0 
2043   
2044      pad0=property(__getfield_pad0, __setfield_pad0, __delfield_pad0, "Not the flag?") 
2045   
2046 -    def __getfield_phonenum(self): 
2047          return self.__field_phonenum.getvalue() 
2048   
2049 -    def __setfield_phonenum(self, value): 
2050          if isinstance(value,USTRING): 
2051              self.__field_phonenum=value 
2052          else: 
2053              self.__field_phonenum=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 
2054   
2055 -    def __delfield_phonenum(self): del self.__field_phonenum 
2056   
2057      phonenum=property(__getfield_phonenum, __setfield_phonenum, __delfield_phonenum, None) 
2058   
2059 -    def __getfield_phonenum_len(self): 
2060          return self.__field_phonenum_len.getvalue() 
2061   
2062 -    def __setfield_phonenum_len(self, value): 
2063          if isinstance(value,UINT): 
2064              self.__field_phonenum_len=value 
2065          else: 
2066              self.__field_phonenum_len=UINT(value,**{'sizeinbytes': 1}) 
2067   
2068 -    def __delfield_phonenum_len(self): del self.__field_phonenum_len 
2069   
2070      phonenum_len=property(__getfield_phonenum_len, __setfield_phonenum_len, __delfield_phonenum_len, None) 
2071   
2072 -    def __getfield_date(self): 
2073          return self.__field_date.getvalue() 
2074   
2075 -    def __setfield_date(self, value): 
2076          if isinstance(value,UINT): 
2077              self.__field_date=value 
2078          else: 
2079              self.__field_date=UINT(value,**{'sizeinbytes': 4}) 
2080   
2081 -    def __delfield_date(self): del self.__field_date 
2082   
2083      date=property(__getfield_date, __setfield_date, __delfield_date, "# seconds since Jan 1, 1980 approximately") 
2084   
2085 -    def __getfield_period(self): 
2086          return self.__field_period.getvalue() 
2087   
2088 -    def __setfield_period(self, value): 
2089          if isinstance(value,UINT): 
2090              self.__field_period=value 
2091          else: 
2092              self.__field_period=UINT(value,**{'sizeinbytes': 1}) 
2093   
2094 -    def __delfield_period(self): del self.__field_period 
2095   
2096      period=property(__getfield_period, __setfield_period, __delfield_period, "No, Daily, Weekly, Monthly, Yearly") 
2097   
2098 -    def __getfield_dom(self): 
2099          return self.__field_dom.getvalue() 
2100   
2101 -    def __setfield_dom(self, value): 
2102          if isinstance(value,UINT): 
2103              self.__field_dom=value 
2104          else: 
2105              self.__field_dom=UINT(value,**{'sizeinbytes': 1}) 
2106   
2107 -    def __delfield_dom(self): del self.__field_dom 
2108   
2109      dom=property(__getfield_dom, __setfield_dom, __delfield_dom, "Day of month for the event") 
2110   
2111 -    def __getfield_datedup(self): 
2112          return self.__field_datedup.getvalue() 
2113   
2114 -    def __setfield_datedup(self, value): 
2115          if isinstance(value,UINT): 
2116              self.__field_datedup=value 
2117          else: 
2118              self.__field_datedup=UINT(value,**{'sizeinbytes': 4}) 
2119   
2120 -    def __delfield_datedup(self): del self.__field_datedup 
2121   
2122      datedup=property(__getfield_datedup, __setfield_datedup, __delfield_datedup, "Copy of the date.  Always the same???") 
2123   
2124 -    def __getfield_name(self): 
2125          return self.__field_name.getvalue() 
2126   
2127 -    def __setfield_name(self, value): 
2128          if isinstance(value,USTRING): 
2129              self.__field_name=value 
2130          else: 
2131              self.__field_name=USTRING(value,**{'sizeinbytes': 16, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
2132   
2133 -    def __delfield_name(self): del self.__field_name 
2134   
2135      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
2136   
2137 -    def __getfield_pad1(self): 
2138          try: self.__field_pad1 
2139          except: 
2140              self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1}) 
2141          return self.__field_pad1.getvalue() 
2142   
2143 -    def __setfield_pad1(self, value): 
2144          if isinstance(value,UNKNOWN): 
2145              self.__field_pad1=value 
2146          else: 
2147              self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 1}) 
2148   
2149 -    def __delfield_pad1(self): del self.__field_pad1 
2150   
2151      pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None) 
2152   
2153 -    def __getfield_name_len(self): 
2154          return self.__field_name_len.getvalue() 
2155   
2156 -    def __setfield_name_len(self, value): 
2157          if isinstance(value,UINT): 
2158              self.__field_name_len=value 
2159          else: 
2160              self.__field_name_len=UINT(value,**{'sizeinbytes': 1}) 
2161   
2162 -    def __delfield_name_len(self): del self.__field_name_len 
2163   
2164      name_len=property(__getfield_name_len, __setfield_name_len, __delfield_name_len, None) 
2165   
2166 -    def __getfield_phonenumbertype(self): 
2167          return self.__field_phonenumbertype.getvalue() 
2168   
2169 -    def __setfield_phonenumbertype(self, value): 
2170          if isinstance(value,UINT): 
2171              self.__field_phonenumbertype=value 
2172          else: 
2173              self.__field_phonenumbertype=UINT(value,**{'sizeinbytes': 1}) 
2174   
2175 -    def __delfield_phonenumbertype(self): del self.__field_phonenumbertype 
2176   
2177      phonenumbertype=property(__getfield_phonenumbertype, __setfield_phonenumbertype, __delfield_phonenumbertype, "1: Home, 2: Work, ...") 
2178   
2179 -    def __getfield_phonenumberslot(self): 
2180          return self.__field_phonenumberslot.getvalue() 
2181   
2182 -    def __setfield_phonenumberslot(self, value): 
2183          if isinstance(value,UINT): 
2184              self.__field_phonenumberslot=value 
2185          else: 
2186              self.__field_phonenumberslot=UINT(value,**{'sizeinbytes': 2}) 
2187   
2188 -    def __delfield_phonenumberslot(self): del self.__field_phonenumberslot 
2189   
2190      phonenumberslot=property(__getfield_phonenumberslot, __setfield_phonenumberslot, __delfield_phonenumberslot, None) 
2191   
2192 -    def __getfield_pad2(self): 
2193          try: self.__field_pad2 
2194          except: 
2195              self.__field_pad2=UNKNOWN(**{'sizeinbytes': 1}) 
2196          return self.__field_pad2.getvalue() 
2197   
2198 -    def __setfield_pad2(self, value): 
2199          if isinstance(value,UNKNOWN): 
2200              self.__field_pad2=value 
2201          else: 
2202              self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 1}) 
2203   
2204 -    def __delfield_pad2(self): del self.__field_pad2 
2205   
2206      pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None) 
2207   
2208 -    def __getfield_serial(self): 
2209          try: self.__field_serial 
2210          except: 
2211              self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 
2212          return self.__field_serial.getvalue() 
2213   
2214 -    def __setfield_serial(self, value): 
2215          if isinstance(value,UINT): 
2216              self.__field_serial=value 
2217          else: 
2218              self.__field_serial=UINT(value,**{'sizeinbytes': 1, 'default': 0}) 
2219   
2220 -    def __delfield_serial(self): del self.__field_serial 
2221   
2222      serial=property(__getfield_serial, __setfield_serial, __delfield_serial, None) 
2223   
2224 -    def __getfield_pad3(self): 
2225          try: self.__field_pad3 
2226          except: 
2227              self.__field_pad3=UNKNOWN(**{'sizeinbytes': 2}) 
2228          return self.__field_pad3.getvalue() 
2229   
2230 -    def __setfield_pad3(self, value): 
2231          if isinstance(value,UNKNOWN): 
2232              self.__field_pad3=value 
2233          else: 
2234              self.__field_pad3=UNKNOWN(value,**{'sizeinbytes': 2}) 
2235   
2236 -    def __delfield_pad3(self): del self.__field_pad3 
2237   
2238      pad3=property(__getfield_pad3, __setfield_pad3, __delfield_pad3, None) 
2239   
2240 -    def __getfield_ringtone(self): 
2241          try: self.__field_ringtone 
2242          except: 
2243              self.__field_ringtone=UINT(**{'sizeinbytes': 1, 'default': 0xfc}) 
2244          return self.__field_ringtone.getvalue() 
2245   
2246 -    def __setfield_ringtone(self, value): 
2247          if isinstance(value,UINT): 
2248              self.__field_ringtone=value 
2249          else: 
2250              self.__field_ringtone=UINT(value,**{'sizeinbytes': 1, 'default': 0xfc}) 
2251   
2252 -    def __delfield_ringtone(self): del self.__field_ringtone 
2253   
2254      ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 
2255   
2256 -    def __getfield_pad4(self): 
2257          try: self.__field_pad4 
2258          except: 
2259              self.__field_pad4=UNKNOWN(**{'sizeinbytes': 1}) 
2260          return self.__field_pad4.getvalue() 
2261   
2262 -    def __setfield_pad4(self, value): 
2263          if isinstance(value,UNKNOWN): 
2264              self.__field_pad4=value 
2265          else: 
2266              self.__field_pad4=UNKNOWN(value,**{'sizeinbytes': 1}) 
2267   
2268 -    def __delfield_pad4(self): del self.__field_pad4 
2269   
2270      pad4=property(__getfield_pad4, __setfield_pad4, __delfield_pad4, " This may be the ringtone.  Need to understand ") 
2271   
2272 -    def __getfield_flag(self): 
2273          try: self.__field_flag 
2274          except: 
2275              self.__field_flag=UINT(**{'sizeinbytes': 1}) 
2276          return self.__field_flag.getvalue() 
2277   
2278 -    def __setfield_flag(self, value): 
2279          if isinstance(value,UINT): 
2280              self.__field_flag=value 
2281          else: 
2282              self.__field_flag=UINT(value,**{'sizeinbytes': 1}) 
2283   
2284 -    def __delfield_flag(self): del self.__field_flag 
2285   
2286      flag=property(__getfield_flag, __setfield_flag, __delfield_flag, None) 
2287   
2288 -    def iscontainer(self): 
2289          return True 
2290   
2291 -    def containerelements(self): 
2292          yield ('slot', self.__field_slot, None) 
2293          yield ('pad0', self.__field_pad0, "Not the flag?") 
2294          yield ('phonenum', self.__field_phonenum, None) 
2295          yield ('phonenum_len', self.__field_phonenum_len, None) 
2296          yield ('date', self.__field_date, "# seconds since Jan 1, 1980 approximately") 
2297          yield ('period', self.__field_period, "No, Daily, Weekly, Monthly, Yearly") 
2298          yield ('dom', self.__field_dom, "Day of month for the event") 
2299          yield ('datedup', self.__field_datedup, "Copy of the date.  Always the same???") 
2300          yield ('name', self.__field_name, None) 
2301          yield ('pad1', self.__field_pad1, None) 
2302          yield ('name_len', self.__field_name_len, None) 
2303          yield ('phonenumbertype', self.__field_phonenumbertype, "1: Home, 2: Work, ...") 
2304          yield ('phonenumberslot', self.__field_phonenumberslot, None) 
2305          yield ('pad2', self.__field_pad2, None) 
2306          yield ('serial', self.__field_serial, None) 
2307          yield ('pad3', self.__field_pad3, None) 
2308          yield ('ringtone', self.__field_ringtone, None) 
2309          yield ('pad4', self.__field_pad4, " This may be the ringtone.  Need to understand ") 
2310          yield ('flag', self.__field_flag, None) 
2311   
2312   
2313   
2314   
2315 -class todorequest(BaseProtogenClass): 
2316      __fields=['header', 'slot', 'pad'] 
2317   
2318 -    def __init__(self, *args, **kwargs): 
2319          dict={} 
2320          # What was supplied to this function 
2321          dict.update(kwargs) 
2322          # Parent constructor 
2323          super(todorequest,self).__init__(**dict) 
2324          if self.__class__ is todorequest: 
2325              self._update(args,dict) 
2326   
2327   
2328 -    def getfields(self): 
2329          return self.__fields 
2330   
2331   
2332 -    def _update(self, args, kwargs): 
2333          super(todorequest,self)._update(args,kwargs) 
2334          keys=kwargs.keys() 
2335          for key in keys: 
2336              if key in self.__fields: 
2337                  setattr(self, key, kwargs[key]) 
2338                  del kwargs[key] 
2339          # Were any unrecognized kwargs passed in? 
2340          if __debug__: 
2341              self._complainaboutunusedargs(todorequest,kwargs) 
2342          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2343          # Make all P fields that haven't already been constructed 
2344   
2345   
2346 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2347          'Writes this packet to the supplied buffer' 
2348          self._bufferstartoffset=buf.getcurrentoffset() 
2349          try: self.__field_header 
2350          except: 
2351              self.__field_header=qcpheader(**{'packettype': 0x0c, 'command': 0x25}) 
2352          self.__field_header.writetobuffer(buf) 
2353          self.__field_slot.writetobuffer(buf) 
2354          try: self.__field_pad 
2355          except: 
2356              self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 
2357          self.__field_pad.writetobuffer(buf) 
2358          self._bufferendoffset=buf.getcurrentoffset() 
2359          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2360   
2361   
2362 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2363          'Reads this packet from the supplied buffer' 
2364          self._bufferstartoffset=buf.getcurrentoffset() 
2365          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2366          self.__field_header=qcpheader(**{'packettype': 0x0c, 'command': 0x25}) 
2367          self.__field_header.readfrombuffer(buf) 
2368          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
2369          self.__field_slot.readfrombuffer(buf) 
2370          self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 
2371          self.__field_pad.readfrombuffer(buf) 
2372          self._bufferendoffset=buf.getcurrentoffset() 
2373   
2374   
2375 -    def __getfield_header(self): 
2376          try: self.__field_header 
2377          except: 
2378              self.__field_header=qcpheader(**{'packettype': 0x0c, 'command': 0x25}) 
2379          return self.__field_header.getvalue() 
2380   
2381 -    def __setfield_header(self, value): 
2382          if isinstance(value,qcpheader): 
2383              self.__field_header=value 
2384          else: 
2385              self.__field_header=qcpheader(value,**{'packettype': 0x0c, 'command': 0x25}) 
2386   
2387 -    def __delfield_header(self): del self.__field_header 
2388   
2389      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
2390   
2391 -    def __getfield_slot(self): 
2392          return self.__field_slot.getvalue() 
2393   
2394 -    def __setfield_slot(self, value): 
2395          if isinstance(value,UINT): 
2396              self.__field_slot=value 
2397          else: 
2398              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
2399   
2400 -    def __delfield_slot(self): del self.__field_slot 
2401   
2402      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
2403   
2404 -    def __getfield_pad(self): 
2405          try: self.__field_pad 
2406          except: 
2407              self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 
2408          return self.__field_pad.getvalue() 
2409   
2410 -    def __setfield_pad(self, value): 
2411          if isinstance(value,UNKNOWN): 
2412              self.__field_pad=value 
2413          else: 
2414              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 129}) 
2415   
2416 -    def __delfield_pad(self): del self.__field_pad 
2417   
2418      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
2419   
2420 -    def iscontainer(self): 
2421          return True 
2422   
2423 -    def containerelements(self): 
2424          yield ('header', self.__field_header, None) 
2425          yield ('slot', self.__field_slot, None) 
2426          yield ('pad', self.__field_pad, None) 
2427   
2428   
2429   
2430   
2431 -class todoentry(BaseProtogenClass): 
2432      __fields=['slot', 'flag', 'todo', 'pad1', 'todo_len', 'priority', 'dunno', 'order'] 
2433   
2434 -    def __init__(self, *args, **kwargs): 
2435          dict={} 
2436          # What was supplied to this function 
2437          dict.update(kwargs) 
2438          # Parent constructor 
2439          super(todoentry,self).__init__(**dict) 
2440          if self.__class__ is todoentry: 
2441              self._update(args,dict) 
2442   
2443   
2444 -    def getfields(self): 
2445          return self.__fields 
2446   
2447   
2448 -    def _update(self, args, kwargs): 
2449          super(todoentry,self)._update(args,kwargs) 
2450          keys=kwargs.keys() 
2451          for key in keys: 
2452              if key in self.__fields: 
2453                  setattr(self, key, kwargs[key]) 
2454                  del kwargs[key] 
2455          # Were any unrecognized kwargs passed in? 
2456          if __debug__: 
2457              self._complainaboutunusedargs(todoentry,kwargs) 
2458          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2459          # Make all P fields that haven't already been constructed 
2460   
2461   
2462 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2463          'Writes this packet to the supplied buffer' 
2464          self._bufferstartoffset=buf.getcurrentoffset() 
2465          self.__field_slot.writetobuffer(buf) 
2466          self.__field_flag.writetobuffer(buf) 
2467          self.__field_todo.writetobuffer(buf) 
2468          try: self.__field_pad1 
2469          except: 
2470              self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7}) 
2471          self.__field_pad1.writetobuffer(buf) 
2472          self.__field_todo_len.writetobuffer(buf) 
2473          self.__field_priority.writetobuffer(buf) 
2474          try: self.__field_dunno 
2475          except: 
2476              self.__field_dunno=UINT(**{'sizeinbytes': 1}) 
2477          self.__field_dunno.writetobuffer(buf) 
2478          self.__field_order.writetobuffer(buf) 
2479          self._bufferendoffset=buf.getcurrentoffset() 
2480          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2481   
2482   
2483 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2484          'Reads this packet from the supplied buffer' 
2485          self._bufferstartoffset=buf.getcurrentoffset() 
2486          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2487          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
2488          self.__field_slot.readfrombuffer(buf) 
2489          self.__field_flag=UINT(**{'sizeinbytes': 1}) 
2490          self.__field_flag.readfrombuffer(buf) 
2491          self.__field_todo=USTRING(**{'sizeinbytes': 14, 'raiseonunterminatedread': False}) 
2492          self.__field_todo.readfrombuffer(buf) 
2493          self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7}) 
2494          self.__field_pad1.readfrombuffer(buf) 
2495          self.__field_todo_len=UINT(**{'sizeinbytes': 1}) 
2496          self.__field_todo_len.readfrombuffer(buf) 
2497          self.__field_priority=UINT(**{'sizeinbytes': 1}) 
2498          self.__field_priority.readfrombuffer(buf) 
2499          self.__field_dunno=UINT(**{'sizeinbytes': 1}) 
2500          self.__field_dunno.readfrombuffer(buf) 
2501          self.__field_order=UINT(**{'sizeinbytes': 1}) 
2502          self.__field_order.readfrombuffer(buf) 
2503          self._bufferendoffset=buf.getcurrentoffset() 
2504   
2505   
2506 -    def __getfield_slot(self): 
2507          return self.__field_slot.getvalue() 
2508   
2509 -    def __setfield_slot(self, value): 
2510          if isinstance(value,UINT): 
2511              self.__field_slot=value 
2512          else: 
2513              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
2514   
2515 -    def __delfield_slot(self): del self.__field_slot 
2516   
2517      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
2518   
2519 -    def __getfield_flag(self): 
2520          return self.__field_flag.getvalue() 
2521   
2522 -    def __setfield_flag(self, value): 
2523          if isinstance(value,UINT): 
2524              self.__field_flag=value 
2525          else: 
2526              self.__field_flag=UINT(value,**{'sizeinbytes': 1}) 
2527   
2528 -    def __delfield_flag(self): del self.__field_flag 
2529   
2530      flag=property(__getfield_flag, __setfield_flag, __delfield_flag, "0: Not used, 1: Used") 
2531   
2532 -    def __getfield_todo(self): 
2533          return self.__field_todo.getvalue() 
2534   
2535 -    def __setfield_todo(self, value): 
2536          if isinstance(value,USTRING): 
2537              self.__field_todo=value 
2538          else: 
2539              self.__field_todo=USTRING(value,**{'sizeinbytes': 14, 'raiseonunterminatedread': False}) 
2540   
2541 -    def __delfield_todo(self): del self.__field_todo 
2542   
2543      todo=property(__getfield_todo, __setfield_todo, __delfield_todo, None) 
2544   
2545 -    def __getfield_pad1(self): 
2546          try: self.__field_pad1 
2547          except: 
2548              self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7}) 
2549          return self.__field_pad1.getvalue() 
2550   
2551 -    def __setfield_pad1(self, value): 
2552          if isinstance(value,UNKNOWN): 
2553              self.__field_pad1=value 
2554          else: 
2555              self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 7}) 
2556   
2557 -    def __delfield_pad1(self): del self.__field_pad1 
2558   
2559      pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None) 
2560   
2561 -    def __getfield_todo_len(self): 
2562          return self.__field_todo_len.getvalue() 
2563   
2564 -    def __setfield_todo_len(self, value): 
2565          if isinstance(value,UINT): 
2566              self.__field_todo_len=value 
2567          else: 
2568              self.__field_todo_len=UINT(value,**{'sizeinbytes': 1}) 
2569   
2570 -    def __delfield_todo_len(self): del self.__field_todo_len 
2571   
2572      todo_len=property(__getfield_todo_len, __setfield_todo_len, __delfield_todo_len, None) 
2573   
2574 -    def __getfield_priority(self): 
2575          return self.__field_priority.getvalue() 
2576   
2577 -    def __setfield_priority(self, value): 
2578          if isinstance(value,UINT): 
2579              self.__field_priority=value 
2580          else: 
2581              self.__field_priority=UINT(value,**{'sizeinbytes': 1}) 
2582   
2583 -    def __delfield_priority(self): del self.__field_priority 
2584   
2585      priority=property(__getfield_priority, __setfield_priority, __delfield_priority, "0: Normal, 1: Urgent, 2: Done") 
2586   
2587 -    def __getfield_dunno(self): 
2588          try: self.__field_dunno 
2589          except: 
2590              self.__field_dunno=UINT(**{'sizeinbytes': 1}) 
2591          return self.__field_dunno.getvalue() 
2592   
2593 -    def __setfield_dunno(self, value): 
2594          if isinstance(value,UINT): 
2595              self.__field_dunno=value 
2596          else: 
2597              self.__field_dunno=UINT(value,**{'sizeinbytes': 1}) 
2598   
2599 -    def __delfield_dunno(self): del self.__field_dunno 
2600   
2601      dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, "Maybe always zero") 
2602   
2603 -    def __getfield_order(self): 
2604          return self.__field_order.getvalue() 
2605   
2606 -    def __setfield_order(self, value): 
2607          if isinstance(value,UINT): 
2608              self.__field_order=value 
2609          else: 
2610              self.__field_order=UINT(value,**{'sizeinbytes': 1}) 
2611   
2612 -    def __delfield_order(self): del self.__field_order 
2613   
2614      order=property(__getfield_order, __setfield_order, __delfield_order, "Gets sorted on screen in this order") 
2615   
2616 -    def iscontainer(self): 
2617          return True 
2618   
2619 -    def containerelements(self): 
2620          yield ('slot', self.__field_slot, None) 
2621          yield ('flag', self.__field_flag, "0: Not used, 1: Used") 
2622          yield ('todo', self.__field_todo, None) 
2623          yield ('pad1', self.__field_pad1, None) 
2624          yield ('todo_len', self.__field_todo_len, None) 
2625          yield ('priority', self.__field_priority, "0: Normal, 1: Urgent, 2: Done") 
2626          yield ('dunno', self.__field_dunno, "Maybe always zero") 
2627          yield ('order', self.__field_order, "Gets sorted on screen in this order") 
2628   
2629   
2630   
2631   
2632 -class todoresponse(BaseProtogenClass): 
2633      __fields=['header', 'entry', 'pad'] 
2634   
2635 -    def __init__(self, *args, **kwargs): 
2636          dict={} 
2637          # What was supplied to this function 
2638          dict.update(kwargs) 
2639          # Parent constructor 
2640          super(todoresponse,self).__init__(**dict) 
2641          if self.__class__ is todoresponse: 
2642              self._update(args,dict) 
2643   
2644   
2645 -    def getfields(self): 
2646          return self.__fields 
2647   
2648   
2649 -    def _update(self, args, kwargs): 
2650          super(todoresponse,self)._update(args,kwargs) 
2651          keys=kwargs.keys() 
2652          for key in keys: 
2653              if key in self.__fields: 
2654                  setattr(self, key, kwargs[key]) 
2655                  del kwargs[key] 
2656          # Were any unrecognized kwargs passed in? 
2657          if __debug__: 
2658              self._complainaboutunusedargs(todoresponse,kwargs) 
2659          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2660          # Make all P fields that haven't already been constructed 
2661   
2662   
2663 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2664          'Writes this packet to the supplied buffer' 
2665          self._bufferstartoffset=buf.getcurrentoffset() 
2666          self.__field_header.writetobuffer(buf) 
2667          self.__field_entry.writetobuffer(buf) 
2668          self.__field_pad.writetobuffer(buf) 
2669          self._bufferendoffset=buf.getcurrentoffset() 
2670          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2671   
2672   
2673 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2674          'Reads this packet from the supplied buffer' 
2675          self._bufferstartoffset=buf.getcurrentoffset() 
2676          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2677          self.__field_header=qcpheader() 
2678          self.__field_header.readfrombuffer(buf) 
2679          self.__field_entry=todoentry() 
2680          self.__field_entry.readfrombuffer(buf) 
2681          self.__field_pad=UNKNOWN() 
2682          self.__field_pad.readfrombuffer(buf) 
2683          self._bufferendoffset=buf.getcurrentoffset() 
2684   
2685   
2686 -    def __getfield_header(self): 
2687          return self.__field_header.getvalue() 
2688   
2689 -    def __setfield_header(self, value): 
2690          if isinstance(value,qcpheader): 
2691              self.__field_header=value 
2692          else: 
2693              self.__field_header=qcpheader(value,) 
2694   
2695 -    def __delfield_header(self): del self.__field_header 
2696   
2697      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
2698   
2699 -    def __getfield_entry(self): 
2700          return self.__field_entry.getvalue() 
2701   
2702 -    def __setfield_entry(self, value): 
2703          if isinstance(value,todoentry): 
2704              self.__field_entry=value 
2705          else: 
2706              self.__field_entry=todoentry(value,) 
2707   
2708 -    def __delfield_entry(self): del self.__field_entry 
2709   
2710      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
2711   
2712 -    def __getfield_pad(self): 
2713          return self.__field_pad.getvalue() 
2714   
2715 -    def __setfield_pad(self, value): 
2716          if isinstance(value,UNKNOWN): 
2717              self.__field_pad=value 
2718          else: 
2719              self.__field_pad=UNKNOWN(value,) 
2720   
2721 -    def __delfield_pad(self): del self.__field_pad 
2722   
2723      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
2724   
2725 -    def iscontainer(self): 
2726          return True 
2727   
2728 -    def containerelements(self): 
2729          yield ('header', self.__field_header, None) 
2730          yield ('entry', self.__field_entry, None) 
2731          yield ('pad', self.__field_pad, None) 
2732