Source Code for Module phones.p_sanyo5600

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