Source Code for Module phones.p_sanyo3200

   1  # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE 
   2   
   3  """Various descriptions of data specific to Sanyo SCP-3200""" 
   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  from p_brew import * 
  12   
  13  # We use LSB for all integer like fields 
  14  UINT=UINTlsb 
  15  BOOL=BOOLlsb 
  16  _NUMPBSLOTS=300 
  17  _NUMSPEEDDIALS=8 
  18  _NUMLONGNUMBERS=5 
  19  _LONGPHONENUMBERLEN=30 
  20  _NUMEVENTSLOTS=100 
  21  _NUMCALLALARMSLOTS=15 
  22   # Need to check.  Is max phone will hold 32/96 or 33/97 
  23  _MAXNUMBERLEN=32 
  24  _MAXEMAILLEN=96 
  25  HASRINGPICBUF=0 
  26   
  27  #BREW_FILE_SYSTEM=2 
  28   
  29 -class req41(BaseProtogenClass): 
  30      __fields=['fortyone', 'msl'] 
  31   
  32 -    def __init__(self, *args, **kwargs): 
  33          dict={} 
  34          # What was supplied to this function 
  35          dict.update(kwargs) 
  36          # Parent constructor 
  37          super(req41,self).__init__(**dict) 
  38          if self.__class__ is req41: 
  39              self._update(args,dict) 
  40   
  41   
  42 -    def getfields(self): 
  43          return self.__fields 
  44   
  45   
  46 -    def _update(self, args, kwargs): 
  47          super(req41,self)._update(args,kwargs) 
  48          keys=kwargs.keys() 
  49          for key in keys: 
  50              if key in self.__fields: 
  51                  setattr(self, key, kwargs[key]) 
  52                  del kwargs[key] 
  53          # Were any unrecognized kwargs passed in? 
  54          if __debug__: 
  55              self._complainaboutunusedargs(req41,kwargs) 
  56          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
  57          # Make all P fields that haven't already been constructed 
  58   
  59   
  60 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
  61          'Writes this packet to the supplied buffer' 
  62          self._bufferstartoffset=buf.getcurrentoffset() 
  63          try: self.__field_fortyone 
  64          except: 
  65              self.__field_fortyone=UINT(**{'sizeinbytes': 1, 'default': 0x41}) 
  66          self.__field_fortyone.writetobuffer(buf) 
  67          self.__field_msl.writetobuffer(buf) 
  68          self._bufferendoffset=buf.getcurrentoffset() 
  69          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
  70   
  71   
  72 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
  73          'Reads this packet from the supplied buffer' 
  74          self._bufferstartoffset=buf.getcurrentoffset() 
  75          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
  76          self.__field_fortyone=UINT(**{'sizeinbytes': 1, 'default': 0x41}) 
  77          self.__field_fortyone.readfrombuffer(buf) 
  78          self.__field_msl=USTRING(**{'sizeinbytes': 6, 'terminator': None}) 
  79          self.__field_msl.readfrombuffer(buf) 
  80          self._bufferendoffset=buf.getcurrentoffset() 
  81   
  82   
  83 -    def __getfield_fortyone(self): 
  84          try: self.__field_fortyone 
  85          except: 
  86              self.__field_fortyone=UINT(**{'sizeinbytes': 1, 'default': 0x41}) 
  87          return self.__field_fortyone.getvalue() 
  88   
  89 -    def __setfield_fortyone(self, value): 
  90          if isinstance(value,UINT): 
  91              self.__field_fortyone=value 
  92          else: 
  93              self.__field_fortyone=UINT(value,**{'sizeinbytes': 1, 'default': 0x41}) 
  94   
  95 -    def __delfield_fortyone(self): del self.__field_fortyone 
  96   
  97      fortyone=property(__getfield_fortyone, __setfield_fortyone, __delfield_fortyone, None) 
  98   
  99 -    def __getfield_msl(self): 
 100          return self.__field_msl.getvalue() 
 101   
 102 -    def __setfield_msl(self, value): 
 103          if isinstance(value,USTRING): 
 104              self.__field_msl=value 
 105          else: 
 106              self.__field_msl=USTRING(value,**{'sizeinbytes': 6, 'terminator': None}) 
 107   
 108 -    def __delfield_msl(self): del self.__field_msl 
 109   
 110      msl=property(__getfield_msl, __setfield_msl, __delfield_msl, None) 
 111   
 112 -    def iscontainer(self): 
 113          return True 
 114   
 115 -    def containerelements(self): 
 116          yield ('fortyone', self.__field_fortyone, None) 
 117          yield ('msl', self.__field_msl, None) 
 118   
 119   
 120   
 121   
 122 -class res41(BaseProtogenClass): 
 123      __fields=['fortyone', 'ans'] 
 124   
 125 -    def __init__(self, *args, **kwargs): 
 126          dict={} 
 127          # What was supplied to this function 
 128          dict.update(kwargs) 
 129          # Parent constructor 
 130          super(res41,self).__init__(**dict) 
 131          if self.__class__ is res41: 
 132              self._update(args,dict) 
 133   
 134   
 135 -    def getfields(self): 
 136          return self.__fields 
 137   
 138   
 139 -    def _update(self, args, kwargs): 
 140          super(res41,self)._update(args,kwargs) 
 141          keys=kwargs.keys() 
 142          for key in keys: 
 143              if key in self.__fields: 
 144                  setattr(self, key, kwargs[key]) 
 145                  del kwargs[key] 
 146          # Were any unrecognized kwargs passed in? 
 147          if __debug__: 
 148              self._complainaboutunusedargs(res41,kwargs) 
 149          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 150          # Make all P fields that haven't already been constructed 
 151   
 152   
 153 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 154          'Writes this packet to the supplied buffer' 
 155          self._bufferstartoffset=buf.getcurrentoffset() 
 156          self.__field_fortyone.writetobuffer(buf) 
 157          self.__field_ans.writetobuffer(buf) 
 158          self._bufferendoffset=buf.getcurrentoffset() 
 159          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 160   
 161   
 162 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 163          'Reads this packet from the supplied buffer' 
 164          self._bufferstartoffset=buf.getcurrentoffset() 
 165          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 166          self.__field_fortyone=UINT(**{'sizeinbytes': 1, 'default': 0x41}) 
 167          self.__field_fortyone.readfrombuffer(buf) 
 168          self.__field_ans=UINT(**{'sizeinbytes': 1}) 
 169          self.__field_ans.readfrombuffer(buf) 
 170          self._bufferendoffset=buf.getcurrentoffset() 
 171   
 172   
 173 -    def __getfield_fortyone(self): 
 174          return self.__field_fortyone.getvalue() 
 175   
 176 -    def __setfield_fortyone(self, value): 
 177          if isinstance(value,UINT): 
 178              self.__field_fortyone=value 
 179          else: 
 180              self.__field_fortyone=UINT(value,**{'sizeinbytes': 1, 'default': 0x41}) 
 181   
 182 -    def __delfield_fortyone(self): del self.__field_fortyone 
 183   
 184      fortyone=property(__getfield_fortyone, __setfield_fortyone, __delfield_fortyone, None) 
 185   
 186 -    def __getfield_ans(self): 
 187          return self.__field_ans.getvalue() 
 188   
 189 -    def __setfield_ans(self, value): 
 190          if isinstance(value,UINT): 
 191              self.__field_ans=value 
 192          else: 
 193              self.__field_ans=UINT(value,**{'sizeinbytes': 1}) 
 194   
 195 -    def __delfield_ans(self): del self.__field_ans 
 196   
 197      ans=property(__getfield_ans, __setfield_ans, __delfield_ans, None) 
 198   
 199 -    def iscontainer(self): 
 200          return True 
 201   
 202 -    def containerelements(self): 
 203          yield ('fortyone', self.__field_fortyone, None) 
 204          yield ('ans', self.__field_ans, None) 
 205   
 206   
 207   
 208   
 209 -class fastatusrequest(BaseProtogenClass): 
 210      __fields=['preamble', 'command', 'packettype'] 
 211   
 212 -    def __init__(self, *args, **kwargs): 
 213          dict={} 
 214          # What was supplied to this function 
 215          dict.update(kwargs) 
 216          # Parent constructor 
 217          super(fastatusrequest,self).__init__(**dict) 
 218          if self.__class__ is fastatusrequest: 
 219              self._update(args,dict) 
 220   
 221   
 222 -    def getfields(self): 
 223          return self.__fields 
 224   
 225   
 226 -    def _update(self, args, kwargs): 
 227          super(fastatusrequest,self)._update(args,kwargs) 
 228          keys=kwargs.keys() 
 229          for key in keys: 
 230              if key in self.__fields: 
 231                  setattr(self, key, kwargs[key]) 
 232                  del kwargs[key] 
 233          # Were any unrecognized kwargs passed in? 
 234          if __debug__: 
 235              self._complainaboutunusedargs(fastatusrequest,kwargs) 
 236          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 237          # Make all P fields that haven't already been constructed 
 238   
 239   
 240 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 241          'Writes this packet to the supplied buffer' 
 242          self._bufferstartoffset=buf.getcurrentoffset() 
 243          try: self.__field_preamble 
 244          except: 
 245              self.__field_preamble=sanyofaheader(**{'faset': 0x13}) 
 246          self.__field_preamble.writetobuffer(buf) 
 247          try: self.__field_command 
 248          except: 
 249              self.__field_command=UINT(**{'sizeinbytes': 1, 'default': 0}) 
 250          self.__field_command.writetobuffer(buf) 
 251          try: self.__field_packettype 
 252          except: 
 253              self.__field_packettype=UINT(**{'sizeinbytes': 1, 'default': 0}) 
 254          self.__field_packettype.writetobuffer(buf) 
 255          self._bufferendoffset=buf.getcurrentoffset() 
 256          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 257   
 258   
 259 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 260          'Reads this packet from the supplied buffer' 
 261          self._bufferstartoffset=buf.getcurrentoffset() 
 262          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 263          self.__field_preamble=sanyofaheader(**{'faset': 0x13}) 
 264          self.__field_preamble.readfrombuffer(buf) 
 265          self.__field_command=UINT(**{'sizeinbytes': 1, 'default': 0}) 
 266          self.__field_command.readfrombuffer(buf) 
 267          self.__field_packettype=UINT(**{'sizeinbytes': 1, 'default': 0}) 
 268          self.__field_packettype.readfrombuffer(buf) 
 269          self._bufferendoffset=buf.getcurrentoffset() 
 270   
 271   
 272 -    def __getfield_preamble(self): 
 273          try: self.__field_preamble 
 274          except: 
 275              self.__field_preamble=sanyofaheader(**{'faset': 0x13}) 
 276          return self.__field_preamble.getvalue() 
 277   
 278 -    def __setfield_preamble(self, value): 
 279          if isinstance(value,sanyofaheader): 
 280              self.__field_preamble=value 
 281          else: 
 282              self.__field_preamble=sanyofaheader(value,**{'faset': 0x13}) 
 283   
 284 -    def __delfield_preamble(self): del self.__field_preamble 
 285   
 286      preamble=property(__getfield_preamble, __setfield_preamble, __delfield_preamble, None) 
 287   
 288 -    def __getfield_command(self): 
 289          try: self.__field_command 
 290          except: 
 291              self.__field_command=UINT(**{'sizeinbytes': 1, 'default': 0}) 
 292          return self.__field_command.getvalue() 
 293   
 294 -    def __setfield_command(self, value): 
 295          if isinstance(value,UINT): 
 296              self.__field_command=value 
 297          else: 
 298              self.__field_command=UINT(value,**{'sizeinbytes': 1, 'default': 0}) 
 299   
 300 -    def __delfield_command(self): del self.__field_command 
 301   
 302      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
 303   
 304 -    def __getfield_packettype(self): 
 305          try: self.__field_packettype 
 306          except: 
 307              self.__field_packettype=UINT(**{'sizeinbytes': 1, 'default': 0}) 
 308          return self.__field_packettype.getvalue() 
 309   
 310 -    def __setfield_packettype(self, value): 
 311          if isinstance(value,UINT): 
 312              self.__field_packettype=value 
 313          else: 
 314              self.__field_packettype=UINT(value,**{'sizeinbytes': 1, 'default': 0}) 
 315   
 316 -    def __delfield_packettype(self): del self.__field_packettype 
 317   
 318      packettype=property(__getfield_packettype, __setfield_packettype, __delfield_packettype, None) 
 319   
 320 -    def iscontainer(self): 
 321          return True 
 322   
 323 -    def containerelements(self): 
 324          yield ('preamble', self.__field_preamble, None) 
 325          yield ('command', self.__field_command, None) 
 326          yield ('packettype', self.__field_packettype, None) 
 327   
 328   
 329   
 330   
 331 -class fastatusresponse(BaseProtogenClass): 
 332      __fields=['preamble', 'status', 'packettype'] 
 333   
 334 -    def __init__(self, *args, **kwargs): 
 335          dict={} 
 336          # What was supplied to this function 
 337          dict.update(kwargs) 
 338          # Parent constructor 
 339          super(fastatusresponse,self).__init__(**dict) 
 340          if self.__class__ is fastatusresponse: 
 341              self._update(args,dict) 
 342   
 343   
 344 -    def getfields(self): 
 345          return self.__fields 
 346   
 347   
 348 -    def _update(self, args, kwargs): 
 349          super(fastatusresponse,self)._update(args,kwargs) 
 350          keys=kwargs.keys() 
 351          for key in keys: 
 352              if key in self.__fields: 
 353                  setattr(self, key, kwargs[key]) 
 354                  del kwargs[key] 
 355          # Were any unrecognized kwargs passed in? 
 356          if __debug__: 
 357              self._complainaboutunusedargs(fastatusresponse,kwargs) 
 358          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 359          # Make all P fields that haven't already been constructed 
 360   
 361   
 362 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 363          'Writes this packet to the supplied buffer' 
 364          self._bufferstartoffset=buf.getcurrentoffset() 
 365          try: self.__field_preamble 
 366          except: 
 367              self.__field_preamble=sanyofaheader() 
 368          self.__field_preamble.writetobuffer(buf) 
 369          self.__field_status.writetobuffer(buf) 
 370          self.__field_packettype.writetobuffer(buf) 
 371          self._bufferendoffset=buf.getcurrentoffset() 
 372          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 373   
 374   
 375 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 376          'Reads this packet from the supplied buffer' 
 377          self._bufferstartoffset=buf.getcurrentoffset() 
 378          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 379          self.__field_preamble=sanyofaheader() 
 380          self.__field_preamble.readfrombuffer(buf) 
 381          self.__field_status=UINT(**{'sizeinbytes': 1, 'default': 0}) 
 382          self.__field_status.readfrombuffer(buf) 
 383          self.__field_packettype=UINT(**{'sizeinbytes': 1, 'default': 0}) 
 384          self.__field_packettype.readfrombuffer(buf) 
 385          self._bufferendoffset=buf.getcurrentoffset() 
 386   
 387   
 388 -    def __getfield_preamble(self): 
 389          try: self.__field_preamble 
 390          except: 
 391              self.__field_preamble=sanyofaheader() 
 392          return self.__field_preamble.getvalue() 
 393   
 394 -    def __setfield_preamble(self, value): 
 395          if isinstance(value,sanyofaheader): 
 396              self.__field_preamble=value 
 397          else: 
 398              self.__field_preamble=sanyofaheader(value,) 
 399   
 400 -    def __delfield_preamble(self): del self.__field_preamble 
 401   
 402      preamble=property(__getfield_preamble, __setfield_preamble, __delfield_preamble, None) 
 403   
 404 -    def __getfield_status(self): 
 405          return self.__field_status.getvalue() 
 406   
 407 -    def __setfield_status(self, value): 
 408          if isinstance(value,UINT): 
 409              self.__field_status=value 
 410          else: 
 411              self.__field_status=UINT(value,**{'sizeinbytes': 1, 'default': 0}) 
 412   
 413 -    def __delfield_status(self): del self.__field_status 
 414   
 415      status=property(__getfield_status, __setfield_status, __delfield_status, None) 
 416   
 417 -    def __getfield_packettype(self): 
 418          return self.__field_packettype.getvalue() 
 419   
 420 -    def __setfield_packettype(self, value): 
 421          if isinstance(value,UINT): 
 422              self.__field_packettype=value 
 423          else: 
 424              self.__field_packettype=UINT(value,**{'sizeinbytes': 1, 'default': 0}) 
 425   
 426 -    def __delfield_packettype(self): del self.__field_packettype 
 427   
 428      packettype=property(__getfield_packettype, __setfield_packettype, __delfield_packettype, None) 
 429   
 430 -    def iscontainer(self): 
 431          return True 
 432   
 433 -    def containerelements(self): 
 434          yield ('preamble', self.__field_preamble, None) 
 435          yield ('status', self.__field_status, None) 
 436          yield ('packettype', self.__field_packettype, None) 
 437   
 438   
 439   
 440   
 441 -class response(BaseProtogenClass): 
 442      __fields=['pad'] 
 443   
 444 -    def __init__(self, *args, **kwargs): 
 445          dict={} 
 446          # What was supplied to this function 
 447          dict.update(kwargs) 
 448          # Parent constructor 
 449          super(response,self).__init__(**dict) 
 450          if self.__class__ is response: 
 451              self._update(args,dict) 
 452   
 453   
 454 -    def getfields(self): 
 455          return self.__fields 
 456   
 457   
 458 -    def _update(self, args, kwargs): 
 459          super(response,self)._update(args,kwargs) 
 460          keys=kwargs.keys() 
 461          for key in keys: 
 462              if key in self.__fields: 
 463                  setattr(self, key, kwargs[key]) 
 464                  del kwargs[key] 
 465          # Were any unrecognized kwargs passed in? 
 466          if __debug__: 
 467              self._complainaboutunusedargs(response,kwargs) 
 468          if len(args): 
 469              dict2={} 
 470              dict2.update(kwargs) 
 471              kwargs=dict2 
 472              self.__field_pad=UNKNOWN(*args,**dict2) 
 473          # Make all P fields that haven't already been constructed 
 474   
 475   
 476 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 477          'Writes this packet to the supplied buffer' 
 478          self._bufferstartoffset=buf.getcurrentoffset() 
 479          self.__field_pad.writetobuffer(buf) 
 480          self._bufferendoffset=buf.getcurrentoffset() 
 481          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 482   
 483   
 484 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 485          'Reads this packet from the supplied buffer' 
 486          self._bufferstartoffset=buf.getcurrentoffset() 
 487          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 488          self.__field_pad=UNKNOWN() 
 489          self.__field_pad.readfrombuffer(buf) 
 490          self._bufferendoffset=buf.getcurrentoffset() 
 491   
 492   
 493 -    def __getfield_pad(self): 
 494          return self.__field_pad.getvalue() 
 495   
 496 -    def __setfield_pad(self, value): 
 497          if isinstance(value,UNKNOWN): 
 498              self.__field_pad=value 
 499          else: 
 500              self.__field_pad=UNKNOWN(value,) 
 501   
 502 -    def __delfield_pad(self): del self.__field_pad 
 503   
 504      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
 505   
 506 -    def iscontainer(self): 
 507          return True 
 508   
 509 -    def containerelements(self): 
 510          yield ('pad', self.__field_pad, None) 
 511   
 512   
 513   
 514   
 515 -class qcpheader(BaseProtogenClass): 
 516      __fields=['readwrite', 'command', 'packettype'] 
 517   
 518 -    def __init__(self, *args, **kwargs): 
 519          dict={} 
 520          # User specified arguments in the packet description 
 521          dict.update({'readwrite': 0x26}) 
 522          # What was supplied to this function 
 523          dict.update(kwargs) 
 524          # Parent constructor 
 525          super(qcpheader,self).__init__(**dict) 
 526          if self.__class__ is qcpheader: 
 527              self._update(args,dict) 
 528   
 529   
 530 -    def getfields(self): 
 531          return self.__fields 
 532   
 533   
 534 -    def _update(self, args, kwargs): 
 535          super(qcpheader,self)._update(args,kwargs) 
 536          keys=kwargs.keys() 
 537          for key in keys: 
 538              if key in self.__fields: 
 539                  setattr(self, key, kwargs[key]) 
 540                  del kwargs[key] 
 541          # Were any unrecognized kwargs passed in? 
 542          if __debug__: 
 543              self._complainaboutunusedargs(qcpheader,kwargs) 
 544          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 545          # Make all P fields that haven't already been constructed 
 546   
 547   
 548 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 549          'Writes this packet to the supplied buffer' 
 550          self._bufferstartoffset=buf.getcurrentoffset() 
 551          self.__field_readwrite.writetobuffer(buf) 
 552          self.__field_command.writetobuffer(buf) 
 553          self.__field_packettype.writetobuffer(buf) 
 554          self._bufferendoffset=buf.getcurrentoffset() 
 555          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 556   
 557   
 558 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 559          'Reads this packet from the supplied buffer' 
 560          self._bufferstartoffset=buf.getcurrentoffset() 
 561          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 562          self.__field_readwrite=UINT(**{'sizeinbytes': 1}) 
 563          self.__field_readwrite.readfrombuffer(buf) 
 564          self.__field_command=UINT(**{'sizeinbytes': 1}) 
 565          self.__field_command.readfrombuffer(buf) 
 566          self.__field_packettype=UINT(**{'sizeinbytes': 1}) 
 567          self.__field_packettype.readfrombuffer(buf) 
 568          self._bufferendoffset=buf.getcurrentoffset() 
 569   
 570   
 571 -    def __getfield_readwrite(self): 
 572          return self.__field_readwrite.getvalue() 
 573   
 574 -    def __setfield_readwrite(self, value): 
 575          if isinstance(value,UINT): 
 576              self.__field_readwrite=value 
 577          else: 
 578              self.__field_readwrite=UINT(value,**{'sizeinbytes': 1}) 
 579   
 580 -    def __delfield_readwrite(self): del self.__field_readwrite 
 581   
 582      readwrite=property(__getfield_readwrite, __setfield_readwrite, __delfield_readwrite, None) 
 583   
 584 -    def __getfield_command(self): 
 585          return self.__field_command.getvalue() 
 586   
 587 -    def __setfield_command(self, value): 
 588          if isinstance(value,UINT): 
 589              self.__field_command=value 
 590          else: 
 591              self.__field_command=UINT(value,**{'sizeinbytes': 1}) 
 592   
 593 -    def __delfield_command(self): del self.__field_command 
 594   
 595      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
 596   
 597 -    def __getfield_packettype(self): 
 598          return self.__field_packettype.getvalue() 
 599   
 600 -    def __setfield_packettype(self, value): 
 601          if isinstance(value,UINT): 
 602              self.__field_packettype=value 
 603          else: 
 604              self.__field_packettype=UINT(value,**{'sizeinbytes': 1}) 
 605   
 606 -    def __delfield_packettype(self): del self.__field_packettype 
 607   
 608      packettype=property(__getfield_packettype, __setfield_packettype, __delfield_packettype, None) 
 609   
 610 -    def iscontainer(self): 
 611          return True 
 612   
 613 -    def containerelements(self): 
 614          yield ('readwrite', self.__field_readwrite, None) 
 615          yield ('command', self.__field_command, None) 
 616          yield ('packettype', self.__field_packettype, None) 
 617   
 618   
 619   
 620   
 621 -class qcpwriteheader(BaseProtogenClass): 
 622      __fields=['readwrite', 'command', 'packettype', 'pad'] 
 623   
 624 -    def __init__(self, *args, **kwargs): 
 625          dict={} 
 626          # User specified arguments in the packet description 
 627          dict.update({'readwrite': 0x27}) 
 628          # What was supplied to this function 
 629          dict.update(kwargs) 
 630          # Parent constructor 
 631          super(qcpwriteheader,self).__init__(**dict) 
 632          if self.__class__ is qcpwriteheader: 
 633              self._update(args,dict) 
 634   
 635   
 636 -    def getfields(self): 
 637          return self.__fields 
 638   
 639   
 640 -    def _update(self, args, kwargs): 
 641          super(qcpwriteheader,self)._update(args,kwargs) 
 642          keys=kwargs.keys() 
 643          for key in keys: 
 644              if key in self.__fields: 
 645                  setattr(self, key, kwargs[key]) 
 646                  del kwargs[key] 
 647          # Were any unrecognized kwargs passed in? 
 648          if __debug__: 
 649              self._complainaboutunusedargs(qcpwriteheader,kwargs) 
 650          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 651          # Make all P fields that haven't already been constructed 
 652   
 653   
 654 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 655          'Writes this packet to the supplied buffer' 
 656          self._bufferstartoffset=buf.getcurrentoffset() 
 657          self.__field_readwrite.writetobuffer(buf) 
 658          self.__field_command.writetobuffer(buf) 
 659          self.__field_packettype.writetobuffer(buf) 
 660          self.__field_pad.writetobuffer(buf) 
 661          self._bufferendoffset=buf.getcurrentoffset() 
 662          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 663   
 664   
 665 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 666          'Reads this packet from the supplied buffer' 
 667          self._bufferstartoffset=buf.getcurrentoffset() 
 668          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 669          self.__field_readwrite=UINT(**{'sizeinbytes': 1}) 
 670          self.__field_readwrite.readfrombuffer(buf) 
 671          self.__field_command=UINT(**{'sizeinbytes': 1}) 
 672          self.__field_command.readfrombuffer(buf) 
 673          self.__field_packettype=UINT(**{'sizeinbytes': 1}) 
 674          self.__field_packettype.readfrombuffer(buf) 
 675          self.__field_pad=UNKNOWN() 
 676          self.__field_pad.readfrombuffer(buf) 
 677          self._bufferendoffset=buf.getcurrentoffset() 
 678   
 679   
 680 -    def __getfield_readwrite(self): 
 681          return self.__field_readwrite.getvalue() 
 682   
 683 -    def __setfield_readwrite(self, value): 
 684          if isinstance(value,UINT): 
 685              self.__field_readwrite=value 
 686          else: 
 687              self.__field_readwrite=UINT(value,**{'sizeinbytes': 1}) 
 688   
 689 -    def __delfield_readwrite(self): del self.__field_readwrite 
 690   
 691      readwrite=property(__getfield_readwrite, __setfield_readwrite, __delfield_readwrite, None) 
 692   
 693 -    def __getfield_command(self): 
 694          return self.__field_command.getvalue() 
 695   
 696 -    def __setfield_command(self, value): 
 697          if isinstance(value,UINT): 
 698              self.__field_command=value 
 699          else: 
 700              self.__field_command=UINT(value,**{'sizeinbytes': 1}) 
 701   
 702 -    def __delfield_command(self): del self.__field_command 
 703   
 704      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
 705   
 706 -    def __getfield_packettype(self): 
 707          return self.__field_packettype.getvalue() 
 708   
 709 -    def __setfield_packettype(self, value): 
 710          if isinstance(value,UINT): 
 711              self.__field_packettype=value 
 712          else: 
 713              self.__field_packettype=UINT(value,**{'sizeinbytes': 1}) 
 714   
 715 -    def __delfield_packettype(self): del self.__field_packettype 
 716   
 717      packettype=property(__getfield_packettype, __setfield_packettype, __delfield_packettype, None) 
 718   
 719 -    def __getfield_pad(self): 
 720          return self.__field_pad.getvalue() 
 721   
 722 -    def __setfield_pad(self, value): 
 723          if isinstance(value,UNKNOWN): 
 724              self.__field_pad=value 
 725          else: 
 726              self.__field_pad=UNKNOWN(value,) 
 727   
 728 -    def __delfield_pad(self): del self.__field_pad 
 729   
 730      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
 731   
 732 -    def iscontainer(self): 
 733          return True 
 734   
 735 -    def containerelements(self): 
 736          yield ('readwrite', self.__field_readwrite, None) 
 737          yield ('command', self.__field_command, None) 
 738          yield ('packettype', self.__field_packettype, None) 
 739          yield ('pad', self.__field_pad, None) 
 740   
 741   
 742   
 743   
 744 -class eventrequest(BaseProtogenClass): 
 745      __fields=['header', 'slot', 'pad'] 
 746   
 747 -    def __init__(self, *args, **kwargs): 
 748          dict={} 
 749          # What was supplied to this function 
 750          dict.update(kwargs) 
 751          # Parent constructor 
 752          super(eventrequest,self).__init__(**dict) 
 753          if self.__class__ is eventrequest: 
 754              self._update(args,dict) 
 755   
 756   
 757 -    def getfields(self): 
 758          return self.__fields 
 759   
 760   
 761 -    def _update(self, args, kwargs): 
 762          super(eventrequest,self)._update(args,kwargs) 
 763          keys=kwargs.keys() 
 764          for key in keys: 
 765              if key in self.__fields: 
 766                  setattr(self, key, kwargs[key]) 
 767                  del kwargs[key] 
 768          # Were any unrecognized kwargs passed in? 
 769          if __debug__: 
 770              self._complainaboutunusedargs(eventrequest,kwargs) 
 771          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 772          # Make all P fields that haven't already been constructed 
 773   
 774   
 775 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 776          'Writes this packet to the supplied buffer' 
 777          self._bufferstartoffset=buf.getcurrentoffset() 
 778          try: self.__field_header 
 779          except: 
 780              self.__field_header=qcpheader(**{'packettype': 0x0c, 'command': 0x23}) 
 781          self.__field_header.writetobuffer(buf) 
 782          self.__field_slot.writetobuffer(buf) 
 783          try: self.__field_pad 
 784          except: 
 785              self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 
 786          self.__field_pad.writetobuffer(buf) 
 787          self._bufferendoffset=buf.getcurrentoffset() 
 788          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 789   
 790   
 791 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 792          'Reads this packet from the supplied buffer' 
 793          self._bufferstartoffset=buf.getcurrentoffset() 
 794          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 795          self.__field_header=qcpheader(**{'packettype': 0x0c, 'command': 0x23}) 
 796          self.__field_header.readfrombuffer(buf) 
 797          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
 798          self.__field_slot.readfrombuffer(buf) 
 799          self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 
 800          self.__field_pad.readfrombuffer(buf) 
 801          self._bufferendoffset=buf.getcurrentoffset() 
 802   
 803   
 804 -    def __getfield_header(self): 
 805          try: self.__field_header 
 806          except: 
 807              self.__field_header=qcpheader(**{'packettype': 0x0c, 'command': 0x23}) 
 808          return self.__field_header.getvalue() 
 809   
 810 -    def __setfield_header(self, value): 
 811          if isinstance(value,qcpheader): 
 812              self.__field_header=value 
 813          else: 
 814              self.__field_header=qcpheader(value,**{'packettype': 0x0c, 'command': 0x23}) 
 815   
 816 -    def __delfield_header(self): del self.__field_header 
 817   
 818      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
 819   
 820 -    def __getfield_slot(self): 
 821          return self.__field_slot.getvalue() 
 822   
 823 -    def __setfield_slot(self, value): 
 824          if isinstance(value,UINT): 
 825              self.__field_slot=value 
 826          else: 
 827              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
 828   
 829 -    def __delfield_slot(self): del self.__field_slot 
 830   
 831      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
 832   
 833 -    def __getfield_pad(self): 
 834          try: self.__field_pad 
 835          except: 
 836              self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 
 837          return self.__field_pad.getvalue() 
 838   
 839 -    def __setfield_pad(self, value): 
 840          if isinstance(value,UNKNOWN): 
 841              self.__field_pad=value 
 842          else: 
 843              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 129}) 
 844   
 845 -    def __delfield_pad(self): del self.__field_pad 
 846   
 847      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
 848   
 849 -    def iscontainer(self): 
 850          return True 
 851   
 852 -    def containerelements(self): 
 853          yield ('header', self.__field_header, None) 
 854          yield ('slot', self.__field_slot, None) 
 855          yield ('pad', self.__field_pad, None) 
 856   
 857   
 858   
 859   
 860 -class eventslotinuserequest(BaseProtogenClass): 
 861      __fields=['header', 'slot', 'pad'] 
 862   
 863 -    def __init__(self, *args, **kwargs): 
 864          dict={} 
 865          # What was supplied to this function 
 866          dict.update(kwargs) 
 867          # Parent constructor 
 868          super(eventslotinuserequest,self).__init__(**dict) 
 869          if self.__class__ is eventslotinuserequest: 
 870              self._update(args,dict) 
 871   
 872   
 873 -    def getfields(self): 
 874          return self.__fields 
 875   
 876   
 877 -    def _update(self, args, kwargs): 
 878          super(eventslotinuserequest,self)._update(args,kwargs) 
 879          keys=kwargs.keys() 
 880          for key in keys: 
 881              if key in self.__fields: 
 882                  setattr(self, key, kwargs[key]) 
 883                  del kwargs[key] 
 884          # Were any unrecognized kwargs passed in? 
 885          if __debug__: 
 886              self._complainaboutunusedargs(eventslotinuserequest,kwargs) 
 887          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 888          # Make all P fields that haven't already been constructed 
 889   
 890   
 891 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 892          'Writes this packet to the supplied buffer' 
 893          self._bufferstartoffset=buf.getcurrentoffset() 
 894          try: self.__field_header 
 895          except: 
 896              self.__field_header=qcpheader(**{'readwrite': 0x26, 'packettype': 0x0d, 'command': 0x74}) 
 897          self.__field_header.writetobuffer(buf) 
 898          self.__field_slot.writetobuffer(buf) 
 899          try: self.__field_pad 
 900          except: 
 901              self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 
 902          self.__field_pad.writetobuffer(buf) 
 903          self._bufferendoffset=buf.getcurrentoffset() 
 904          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 905   
 906   
 907 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 908          'Reads this packet from the supplied buffer' 
 909          self._bufferstartoffset=buf.getcurrentoffset() 
 910          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 911          self.__field_header=qcpheader(**{'readwrite': 0x26, 'packettype': 0x0d, 'command': 0x74}) 
 912          self.__field_header.readfrombuffer(buf) 
 913          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
 914          self.__field_slot.readfrombuffer(buf) 
 915          self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 
 916          self.__field_pad.readfrombuffer(buf) 
 917          self._bufferendoffset=buf.getcurrentoffset() 
 918   
 919   
 920 -    def __getfield_header(self): 
 921          try: self.__field_header 
 922          except: 
 923              self.__field_header=qcpheader(**{'readwrite': 0x26, 'packettype': 0x0d, 'command': 0x74}) 
 924          return self.__field_header.getvalue() 
 925   
 926 -    def __setfield_header(self, value): 
 927          if isinstance(value,qcpheader): 
 928              self.__field_header=value 
 929          else: 
 930              self.__field_header=qcpheader(value,**{'readwrite': 0x26, 'packettype': 0x0d, 'command': 0x74}) 
 931   
 932 -    def __delfield_header(self): del self.__field_header 
 933   
 934      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
 935   
 936 -    def __getfield_slot(self): 
 937          return self.__field_slot.getvalue() 
 938   
 939 -    def __setfield_slot(self, value): 
 940          if isinstance(value,UINT): 
 941              self.__field_slot=value 
 942          else: 
 943              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
 944   
 945 -    def __delfield_slot(self): del self.__field_slot 
 946   
 947      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
 948   
 949 -    def __getfield_pad(self): 
 950          try: self.__field_pad 
 951          except: 
 952              self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 
 953          return self.__field_pad.getvalue() 
 954   
 955 -    def __setfield_pad(self, value): 
 956          if isinstance(value,UNKNOWN): 
 957              self.__field_pad=value 
 958          else: 
 959              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 129}) 
 960   
 961 -    def __delfield_pad(self): del self.__field_pad 
 962   
 963      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
 964   
 965 -    def iscontainer(self): 
 966          return True 
 967   
 968 -    def containerelements(self): 
 969          yield ('header', self.__field_header, None) 
 970          yield ('slot', self.__field_slot, None) 
 971          yield ('pad', self.__field_pad, None) 
 972   
 973   
 974   
 975   
 976 -class evententry(BaseProtogenClass): 
 977      __fields=['slot', 'eventname', 'pad1', 'eventname_len', 'start', 'end', 'location', 'pad2', 'location_len', 'alarmdiff', 'period', 'dom', 'alarm', 'pad3', 'serial', 'pad4', 'ringtone'] 
 978   
 979 -    def __init__(self, *args, **kwargs): 
 980          dict={} 
 981          # What was supplied to this function 
 982          dict.update(kwargs) 
 983          # Parent constructor 
 984          super(evententry,self).__init__(**dict) 
 985          if self.__class__ is evententry: 
 986              self._update(args,dict) 
 987   
 988   
 989 -    def getfields(self): 
 990          return self.__fields 
 991   
 992   
 993 -    def _update(self, args, kwargs): 
 994          super(evententry,self)._update(args,kwargs) 
 995          keys=kwargs.keys() 
 996          for key in keys: 
 997              if key in self.__fields: 
 998                  setattr(self, key, kwargs[key]) 
 999                  del kwargs[key] 
1000          # Were any unrecognized kwargs passed in? 
1001          if __debug__: 
1002              self._complainaboutunusedargs(evententry,kwargs) 
1003          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1004          # Make all P fields that haven't already been constructed 
1005   
1006   
1007 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1008          'Writes this packet to the supplied buffer' 
1009          self._bufferstartoffset=buf.getcurrentoffset() 
1010          self.__field_slot.writetobuffer(buf) 
1011          self.__field_eventname.writetobuffer(buf) 
1012          try: self.__field_pad1 
1013          except: 
1014              self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7}) 
1015          self.__field_pad1.writetobuffer(buf) 
1016          self.__field_eventname_len.writetobuffer(buf) 
1017          self.__field_start.writetobuffer(buf) 
1018          self.__field_end.writetobuffer(buf) 
1019          self.__field_location.writetobuffer(buf) 
1020          try: self.__field_pad2 
1021          except: 
1022              self.__field_pad2=UNKNOWN(**{'sizeinbytes': 7}) 
1023          self.__field_pad2.writetobuffer(buf) 
1024          self.__field_location_len.writetobuffer(buf) 
1025          self.__field_alarmdiff.writetobuffer(buf) 
1026          self.__field_period.writetobuffer(buf) 
1027          self.__field_dom.writetobuffer(buf) 
1028          self.__field_alarm.writetobuffer(buf) 
1029          try: self.__field_pad3 
1030          except: 
1031              self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1}) 
1032          self.__field_pad3.writetobuffer(buf) 
1033          try: self.__field_serial 
1034          except: 
1035              self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 
1036          self.__field_serial.writetobuffer(buf) 
1037          try: self.__field_pad4 
1038          except: 
1039              self.__field_pad4=UNKNOWN(**{'sizeinbytes': 3}) 
1040          self.__field_pad4.writetobuffer(buf) 
1041          self.__field_ringtone.writetobuffer(buf) 
1042          self._bufferendoffset=buf.getcurrentoffset() 
1043          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1044   
1045   
1046 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1047          'Reads this packet from the supplied buffer' 
1048          self._bufferstartoffset=buf.getcurrentoffset() 
1049          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1050          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
1051          self.__field_slot.readfrombuffer(buf) 
1052          self.__field_eventname=USTRING(**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
1053          self.__field_eventname.readfrombuffer(buf) 
1054          self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7}) 
1055          self.__field_pad1.readfrombuffer(buf) 
1056          self.__field_eventname_len=UINT(**{'sizeinbytes': 1}) 
1057          self.__field_eventname_len.readfrombuffer(buf) 
1058          self.__field_start=UINT(**{'sizeinbytes': 4}) 
1059          self.__field_start.readfrombuffer(buf) 
1060          self.__field_end=UINT(**{'sizeinbytes': 4}) 
1061          self.__field_end.readfrombuffer(buf) 
1062          self.__field_location=USTRING(**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
1063          self.__field_location.readfrombuffer(buf) 
1064          self.__field_pad2=UNKNOWN(**{'sizeinbytes': 7}) 
1065          self.__field_pad2.readfrombuffer(buf) 
1066          self.__field_location_len=UINT(**{'sizeinbytes': 1}) 
1067          self.__field_location_len.readfrombuffer(buf) 
1068          self.__field_alarmdiff=UINT(**{'sizeinbytes': 4}) 
1069          self.__field_alarmdiff.readfrombuffer(buf) 
1070          self.__field_period=UINT(**{'sizeinbytes': 1}) 
1071          self.__field_period.readfrombuffer(buf) 
1072          self.__field_dom=UINT(**{'sizeinbytes': 1}) 
1073          self.__field_dom.readfrombuffer(buf) 
1074          self.__field_alarm=UINT(**{'sizeinbytes': 4}) 
1075          self.__field_alarm.readfrombuffer(buf) 
1076          self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1}) 
1077          self.__field_pad3.readfrombuffer(buf) 
1078          self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 
1079          self.__field_serial.readfrombuffer(buf) 
1080          self.__field_pad4=UNKNOWN(**{'sizeinbytes': 3}) 
1081          self.__field_pad4.readfrombuffer(buf) 
1082          self.__field_ringtone=UINT(**{'sizeinbytes': 2}) 
1083          self.__field_ringtone.readfrombuffer(buf) 
1084          self._bufferendoffset=buf.getcurrentoffset() 
1085   
1086   
1087 -    def __getfield_slot(self): 
1088          return self.__field_slot.getvalue() 
1089   
1090 -    def __setfield_slot(self, value): 
1091          if isinstance(value,UINT): 
1092              self.__field_slot=value 
1093          else: 
1094              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
1095   
1096 -    def __delfield_slot(self): del self.__field_slot 
1097   
1098      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
1099   
1100 -    def __getfield_eventname(self): 
1101          return self.__field_eventname.getvalue() 
1102   
1103 -    def __setfield_eventname(self, value): 
1104          if isinstance(value,USTRING): 
1105              self.__field_eventname=value 
1106          else: 
1107              self.__field_eventname=USTRING(value,**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
1108   
1109 -    def __delfield_eventname(self): del self.__field_eventname 
1110   
1111      eventname=property(__getfield_eventname, __setfield_eventname, __delfield_eventname, None) 
1112   
1113 -    def __getfield_pad1(self): 
1114          try: self.__field_pad1 
1115          except: 
1116              self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7}) 
1117          return self.__field_pad1.getvalue() 
1118   
1119 -    def __setfield_pad1(self, value): 
1120          if isinstance(value,UNKNOWN): 
1121              self.__field_pad1=value 
1122          else: 
1123              self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 7}) 
1124   
1125 -    def __delfield_pad1(self): del self.__field_pad1 
1126   
1127      pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None) 
1128   
1129 -    def __getfield_eventname_len(self): 
1130          return self.__field_eventname_len.getvalue() 
1131   
1132 -    def __setfield_eventname_len(self, value): 
1133          if isinstance(value,UINT): 
1134              self.__field_eventname_len=value 
1135          else: 
1136              self.__field_eventname_len=UINT(value,**{'sizeinbytes': 1}) 
1137   
1138 -    def __delfield_eventname_len(self): del self.__field_eventname_len 
1139   
1140      eventname_len=property(__getfield_eventname_len, __setfield_eventname_len, __delfield_eventname_len, None) 
1141   
1142 -    def __getfield_start(self): 
1143          return self.__field_start.getvalue() 
1144   
1145 -    def __setfield_start(self, value): 
1146          if isinstance(value,UINT): 
1147              self.__field_start=value 
1148          else: 
1149              self.__field_start=UINT(value,**{'sizeinbytes': 4}) 
1150   
1151 -    def __delfield_start(self): del self.__field_start 
1152   
1153      start=property(__getfield_start, __setfield_start, __delfield_start, "# seconds since Jan 1, 1980 approximately") 
1154   
1155 -    def __getfield_end(self): 
1156          return self.__field_end.getvalue() 
1157   
1158 -    def __setfield_end(self, value): 
1159          if isinstance(value,UINT): 
1160              self.__field_end=value 
1161          else: 
1162              self.__field_end=UINT(value,**{'sizeinbytes': 4}) 
1163   
1164 -    def __delfield_end(self): del self.__field_end 
1165   
1166      end=property(__getfield_end, __setfield_end, __delfield_end, None) 
1167   
1168 -    def __getfield_location(self): 
1169          return self.__field_location.getvalue() 
1170   
1171 -    def __setfield_location(self, value): 
1172          if isinstance(value,USTRING): 
1173              self.__field_location=value 
1174          else: 
1175              self.__field_location=USTRING(value,**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
1176   
1177 -    def __delfield_location(self): del self.__field_location 
1178   
1179      location=property(__getfield_location, __setfield_location, __delfield_location, None) 
1180   
1181 -    def __getfield_pad2(self): 
1182          try: self.__field_pad2 
1183          except: 
1184              self.__field_pad2=UNKNOWN(**{'sizeinbytes': 7}) 
1185          return self.__field_pad2.getvalue() 
1186   
1187 -    def __setfield_pad2(self, value): 
1188          if isinstance(value,UNKNOWN): 
1189              self.__field_pad2=value 
1190          else: 
1191              self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 7}) 
1192   
1193 -    def __delfield_pad2(self): del self.__field_pad2 
1194   
1195      pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None) 
1196   
1197 -    def __getfield_location_len(self): 
1198          return self.__field_location_len.getvalue() 
1199   
1200 -    def __setfield_location_len(self, value): 
1201          if isinstance(value,UINT): 
1202              self.__field_location_len=value 
1203          else: 
1204              self.__field_location_len=UINT(value,**{'sizeinbytes': 1}) 
1205   
1206 -    def __delfield_location_len(self): del self.__field_location_len 
1207   
1208      location_len=property(__getfield_location_len, __setfield_location_len, __delfield_location_len, None) 
1209   
1210 -    def __getfield_alarmdiff(self): 
1211          return self.__field_alarmdiff.getvalue() 
1212   
1213 -    def __setfield_alarmdiff(self, value): 
1214          if isinstance(value,UINT): 
1215              self.__field_alarmdiff=value 
1216          else: 
1217              self.__field_alarmdiff=UINT(value,**{'sizeinbytes': 4}) 
1218   
1219 -    def __delfield_alarmdiff(self): del self.__field_alarmdiff 
1220   
1221      alarmdiff=property(__getfield_alarmdiff, __setfield_alarmdiff, __delfield_alarmdiff, "Displayed alarm time") 
1222   
1223 -    def __getfield_period(self): 
1224          return self.__field_period.getvalue() 
1225   
1226 -    def __setfield_period(self, value): 
1227          if isinstance(value,UINT): 
1228              self.__field_period=value 
1229          else: 
1230              self.__field_period=UINT(value,**{'sizeinbytes': 1}) 
1231   
1232 -    def __delfield_period(self): del self.__field_period 
1233   
1234      period=property(__getfield_period, __setfield_period, __delfield_period, "No, Daily, Weekly, Monthly, Yearly") 
1235   
1236 -    def __getfield_dom(self): 
1237          return self.__field_dom.getvalue() 
1238   
1239 -    def __setfield_dom(self, value): 
1240          if isinstance(value,UINT): 
1241              self.__field_dom=value 
1242          else: 
1243              self.__field_dom=UINT(value,**{'sizeinbytes': 1}) 
1244   
1245 -    def __delfield_dom(self): del self.__field_dom 
1246   
1247      dom=property(__getfield_dom, __setfield_dom, __delfield_dom, "Day of month for the event") 
1248   
1249 -    def __getfield_alarm(self): 
1250          return self.__field_alarm.getvalue() 
1251   
1252 -    def __setfield_alarm(self, value): 
1253          if isinstance(value,UINT): 
1254              self.__field_alarm=value 
1255          else: 
1256              self.__field_alarm=UINT(value,**{'sizeinbytes': 4}) 
1257   
1258 -    def __delfield_alarm(self): del self.__field_alarm 
1259   
1260      alarm=property(__getfield_alarm, __setfield_alarm, __delfield_alarm, None) 
1261   
1262 -    def __getfield_pad3(self): 
1263          try: self.__field_pad3 
1264          except: 
1265              self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1}) 
1266          return self.__field_pad3.getvalue() 
1267   
1268 -    def __setfield_pad3(self, value): 
1269          if isinstance(value,UNKNOWN): 
1270              self.__field_pad3=value 
1271          else: 
1272              self.__field_pad3=UNKNOWN(value,**{'sizeinbytes': 1}) 
1273   
1274 -    def __delfield_pad3(self): del self.__field_pad3 
1275   
1276      pad3=property(__getfield_pad3, __setfield_pad3, __delfield_pad3, None) 
1277   
1278 -    def __getfield_serial(self): 
1279          try: self.__field_serial 
1280          except: 
1281              self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 
1282          return self.__field_serial.getvalue() 
1283   
1284 -    def __setfield_serial(self, value): 
1285          if isinstance(value,UINT): 
1286              self.__field_serial=value 
1287          else: 
1288              self.__field_serial=UINT(value,**{'sizeinbytes': 1, 'default': 0}) 
1289   
1290 -    def __delfield_serial(self): del self.__field_serial 
1291   
1292      serial=property(__getfield_serial, __setfield_serial, __delfield_serial, "Some kind of serial number") 
1293   
1294 -    def __getfield_pad4(self): 
1295          try: self.__field_pad4 
1296          except: 
1297              self.__field_pad4=UNKNOWN(**{'sizeinbytes': 3}) 
1298          return self.__field_pad4.getvalue() 
1299   
1300 -    def __setfield_pad4(self, value): 
1301          if isinstance(value,UNKNOWN): 
1302              self.__field_pad4=value 
1303          else: 
1304              self.__field_pad4=UNKNOWN(value,**{'sizeinbytes': 3}) 
1305   
1306 -    def __delfield_pad4(self): del self.__field_pad4 
1307   
1308      pad4=property(__getfield_pad4, __setfield_pad4, __delfield_pad4, None) 
1309   
1310 -    def __getfield_ringtone(self): 
1311          return self.__field_ringtone.getvalue() 
1312   
1313 -    def __setfield_ringtone(self, value): 
1314          if isinstance(value,UINT): 
1315              self.__field_ringtone=value 
1316          else: 
1317              self.__field_ringtone=UINT(value,**{'sizeinbytes': 2}) 
1318   
1319 -    def __delfield_ringtone(self): del self.__field_ringtone 
1320   
1321      ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 
1322   
1323 -    def iscontainer(self): 
1324          return True 
1325   
1326 -    def containerelements(self): 
1327          yield ('slot', self.__field_slot, None) 
1328          yield ('eventname', self.__field_eventname, None) 
1329          yield ('pad1', self.__field_pad1, None) 
1330          yield ('eventname_len', self.__field_eventname_len, None) 
1331          yield ('start', self.__field_start, "# seconds since Jan 1, 1980 approximately") 
1332          yield ('end', self.__field_end, None) 
1333          yield ('location', self.__field_location, None) 
1334          yield ('pad2', self.__field_pad2, None) 
1335          yield ('location_len', self.__field_location_len, None) 
1336          yield ('alarmdiff', self.__field_alarmdiff, "Displayed alarm time") 
1337          yield ('period', self.__field_period, "No, Daily, Weekly, Monthly, Yearly") 
1338          yield ('dom', self.__field_dom, "Day of month for the event") 
1339          yield ('alarm', self.__field_alarm, None) 
1340          yield ('pad3', self.__field_pad3, None) 
1341          yield ('serial', self.__field_serial, "Some kind of serial number") 
1342          yield ('pad4', self.__field_pad4, None) 
1343          yield ('ringtone', self.__field_ringtone, None) 
1344   
1345   
1346   
1347   
1348 -class eventresponse(BaseProtogenClass): 
1349      __fields=['header', 'entry', 'pad'] 
1350   
1351 -    def __init__(self, *args, **kwargs): 
1352          dict={} 
1353          # What was supplied to this function 
1354          dict.update(kwargs) 
1355          # Parent constructor 
1356          super(eventresponse,self).__init__(**dict) 
1357          if self.__class__ is eventresponse: 
1358              self._update(args,dict) 
1359   
1360   
1361 -    def getfields(self): 
1362          return self.__fields 
1363   
1364   
1365 -    def _update(self, args, kwargs): 
1366          super(eventresponse,self)._update(args,kwargs) 
1367          keys=kwargs.keys() 
1368          for key in keys: 
1369              if key in self.__fields: 
1370                  setattr(self, key, kwargs[key]) 
1371                  del kwargs[key] 
1372          # Were any unrecognized kwargs passed in? 
1373          if __debug__: 
1374              self._complainaboutunusedargs(eventresponse,kwargs) 
1375          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1376          # Make all P fields that haven't already been constructed 
1377   
1378   
1379 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1380          'Writes this packet to the supplied buffer' 
1381          self._bufferstartoffset=buf.getcurrentoffset() 
1382          self.__field_header.writetobuffer(buf) 
1383          self.__field_entry.writetobuffer(buf) 
1384          self.__field_pad.writetobuffer(buf) 
1385          self._bufferendoffset=buf.getcurrentoffset() 
1386          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1387   
1388   
1389 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1390          'Reads this packet from the supplied buffer' 
1391          self._bufferstartoffset=buf.getcurrentoffset() 
1392          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1393          self.__field_header=qcpheader() 
1394          self.__field_header.readfrombuffer(buf) 
1395          self.__field_entry=evententry() 
1396          self.__field_entry.readfrombuffer(buf) 
1397          self.__field_pad=UNKNOWN() 
1398          self.__field_pad.readfrombuffer(buf) 
1399          self._bufferendoffset=buf.getcurrentoffset() 
1400   
1401   
1402 -    def __getfield_header(self): 
1403          return self.__field_header.getvalue() 
1404   
1405 -    def __setfield_header(self, value): 
1406          if isinstance(value,qcpheader): 
1407              self.__field_header=value 
1408          else: 
1409              self.__field_header=qcpheader(value,) 
1410   
1411 -    def __delfield_header(self): del self.__field_header 
1412   
1413      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
1414   
1415 -    def __getfield_entry(self): 
1416          return self.__field_entry.getvalue() 
1417   
1418 -    def __setfield_entry(self, value): 
1419          if isinstance(value,evententry): 
1420              self.__field_entry=value 
1421          else: 
1422              self.__field_entry=evententry(value,) 
1423   
1424 -    def __delfield_entry(self): del self.__field_entry 
1425   
1426      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
1427   
1428 -    def __getfield_pad(self): 
1429          return self.__field_pad.getvalue() 
1430   
1431 -    def __setfield_pad(self, value): 
1432          if isinstance(value,UNKNOWN): 
1433              self.__field_pad=value 
1434          else: 
1435              self.__field_pad=UNKNOWN(value,) 
1436   
1437 -    def __delfield_pad(self): del self.__field_pad 
1438   
1439      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
1440   
1441 -    def iscontainer(self): 
1442          return True 
1443   
1444 -    def containerelements(self): 
1445          yield ('header', self.__field_header, None) 
1446          yield ('entry', self.__field_entry, None) 
1447          yield ('pad', self.__field_pad, None) 
1448   
1449   
1450   
1451   
1452 -class eventslotinuseresponse(BaseProtogenClass): 
1453      __fields=['header', 'slot', 'flag', 'pad'] 
1454   
1455 -    def __init__(self, *args, **kwargs): 
1456          dict={} 
1457          # What was supplied to this function 
1458          dict.update(kwargs) 
1459          # Parent constructor 
1460          super(eventslotinuseresponse,self).__init__(**dict) 
1461          if self.__class__ is eventslotinuseresponse: 
1462              self._update(args,dict) 
1463   
1464   
1465 -    def getfields(self): 
1466          return self.__fields 
1467   
1468   
1469 -    def _update(self, args, kwargs): 
1470          super(eventslotinuseresponse,self)._update(args,kwargs) 
1471          keys=kwargs.keys() 
1472          for key in keys: 
1473              if key in self.__fields: 
1474                  setattr(self, key, kwargs[key]) 
1475                  del kwargs[key] 
1476          # Were any unrecognized kwargs passed in? 
1477          if __debug__: 
1478              self._complainaboutunusedargs(eventslotinuseresponse,kwargs) 
1479          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1480          # Make all P fields that haven't already been constructed 
1481   
1482   
1483 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1484          'Writes this packet to the supplied buffer' 
1485          self._bufferstartoffset=buf.getcurrentoffset() 
1486          self.__field_header.writetobuffer(buf) 
1487          self.__field_slot.writetobuffer(buf) 
1488          self.__field_flag.writetobuffer(buf) 
1489          self.__field_pad.writetobuffer(buf) 
1490          self._bufferendoffset=buf.getcurrentoffset() 
1491          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1492   
1493   
1494 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1495          'Reads this packet from the supplied buffer' 
1496          self._bufferstartoffset=buf.getcurrentoffset() 
1497          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1498          self.__field_header=qcpheader() 
1499          self.__field_header.readfrombuffer(buf) 
1500          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
1501          self.__field_slot.readfrombuffer(buf) 
1502          self.__field_flag=UINT(**{'sizeinbytes': 1}) 
1503          self.__field_flag.readfrombuffer(buf) 
1504          self.__field_pad=UNKNOWN() 
1505          self.__field_pad.readfrombuffer(buf) 
1506          self._bufferendoffset=buf.getcurrentoffset() 
1507   
1508   
1509 -    def __getfield_header(self): 
1510          return self.__field_header.getvalue() 
1511   
1512 -    def __setfield_header(self, value): 
1513          if isinstance(value,qcpheader): 
1514              self.__field_header=value 
1515          else: 
1516              self.__field_header=qcpheader(value,) 
1517   
1518 -    def __delfield_header(self): del self.__field_header 
1519   
1520      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
1521   
1522 -    def __getfield_slot(self): 
1523          return self.__field_slot.getvalue() 
1524   
1525 -    def __setfield_slot(self, value): 
1526          if isinstance(value,UINT): 
1527              self.__field_slot=value 
1528          else: 
1529              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
1530   
1531 -    def __delfield_slot(self): del self.__field_slot 
1532   
1533      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
1534   
1535 -    def __getfield_flag(self): 
1536          return self.__field_flag.getvalue() 
1537   
1538 -    def __setfield_flag(self, value): 
1539          if isinstance(value,UINT): 
1540              self.__field_flag=value 
1541          else: 
1542              self.__field_flag=UINT(value,**{'sizeinbytes': 1}) 
1543   
1544 -    def __delfield_flag(self): del self.__field_flag 
1545   
1546      flag=property(__getfield_flag, __setfield_flag, __delfield_flag, None) 
1547   
1548 -    def __getfield_pad(self): 
1549          return self.__field_pad.getvalue() 
1550   
1551 -    def __setfield_pad(self, value): 
1552          if isinstance(value,UNKNOWN): 
1553              self.__field_pad=value 
1554          else: 
1555              self.__field_pad=UNKNOWN(value,) 
1556   
1557 -    def __delfield_pad(self): del self.__field_pad 
1558   
1559      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
1560   
1561 -    def iscontainer(self): 
1562          return True 
1563   
1564 -    def containerelements(self): 
1565          yield ('header', self.__field_header, None) 
1566          yield ('slot', self.__field_slot, None) 
1567          yield ('flag', self.__field_flag, None) 
1568          yield ('pad', self.__field_pad, None) 
1569   
1570   
1571   
1572   
1573 -class eventslotinuseupdaterequest(BaseProtogenClass): 
1574      __fields=['header', 'slot', 'flag', 'pad'] 
1575   
1576 -    def __init__(self, *args, **kwargs): 
1577          dict={} 
1578          # What was supplied to this function 
1579          dict.update(kwargs) 
1580          # Parent constructor 
1581          super(eventslotinuseupdaterequest,self).__init__(**dict) 
1582          if self.__class__ is eventslotinuseupdaterequest: 
1583              self._update(args,dict) 
1584   
1585   
1586 -    def getfields(self): 
1587          return self.__fields 
1588   
1589   
1590 -    def _update(self, args, kwargs): 
1591          super(eventslotinuseupdaterequest,self)._update(args,kwargs) 
1592          keys=kwargs.keys() 
1593          for key in keys: 
1594              if key in self.__fields: 
1595                  setattr(self, key, kwargs[key]) 
1596                  del kwargs[key] 
1597          # Were any unrecognized kwargs passed in? 
1598          if __debug__: 
1599              self._complainaboutunusedargs(eventslotinuseupdaterequest,kwargs) 
1600          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1601          # Make all P fields that haven't already been constructed 
1602   
1603   
1604 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1605          'Writes this packet to the supplied buffer' 
1606          self._bufferstartoffset=buf.getcurrentoffset() 
1607          try: self.__field_header 
1608          except: 
1609              self.__field_header=qcpwriteheader(**{'packettype': 0x0d, 'command': 0x74}) 
1610          self.__field_header.writetobuffer(buf) 
1611          self.__field_slot.writetobuffer(buf) 
1612          self.__field_flag.writetobuffer(buf) 
1613          try: self.__field_pad 
1614          except: 
1615              self.__field_pad=UNKNOWN(**{'sizeinbytes': 124}) 
1616          self.__field_pad.writetobuffer(buf) 
1617          self._bufferendoffset=buf.getcurrentoffset() 
1618          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1619   
1620   
1621 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1622          'Reads this packet from the supplied buffer' 
1623          self._bufferstartoffset=buf.getcurrentoffset() 
1624          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1625          self.__field_header=qcpwriteheader(**{'packettype': 0x0d, 'command': 0x74}) 
1626          self.__field_header.readfrombuffer(buf) 
1627          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
1628          self.__field_slot.readfrombuffer(buf) 
1629          self.__field_flag=UINT(**{'sizeinbytes': 1}) 
1630          self.__field_flag.readfrombuffer(buf) 
1631          self.__field_pad=UNKNOWN(**{'sizeinbytes': 124}) 
1632          self.__field_pad.readfrombuffer(buf) 
1633          self._bufferendoffset=buf.getcurrentoffset() 
1634   
1635   
1636 -    def __getfield_header(self): 
1637          try: self.__field_header 
1638          except: 
1639              self.__field_header=qcpwriteheader(**{'packettype': 0x0d, 'command': 0x74}) 
1640          return self.__field_header.getvalue() 
1641   
1642 -    def __setfield_header(self, value): 
1643          if isinstance(value,qcpwriteheader): 
1644              self.__field_header=value 
1645          else: 
1646              self.__field_header=qcpwriteheader(value,**{'packettype': 0x0d, 'command': 0x74}) 
1647   
1648 -    def __delfield_header(self): del self.__field_header 
1649   
1650      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
1651   
1652 -    def __getfield_slot(self): 
1653          return self.__field_slot.getvalue() 
1654   
1655 -    def __setfield_slot(self, value): 
1656          if isinstance(value,UINT): 
1657              self.__field_slot=value 
1658          else: 
1659              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
1660   
1661 -    def __delfield_slot(self): del self.__field_slot 
1662   
1663      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
1664   
1665 -    def __getfield_flag(self): 
1666          return self.__field_flag.getvalue() 
1667   
1668 -    def __setfield_flag(self, value): 
1669          if isinstance(value,UINT): 
1670              self.__field_flag=value 
1671          else: 
1672              self.__field_flag=UINT(value,**{'sizeinbytes': 1}) 
1673   
1674 -    def __delfield_flag(self): del self.__field_flag 
1675   
1676      flag=property(__getfield_flag, __setfield_flag, __delfield_flag, None) 
1677   
1678 -    def __getfield_pad(self): 
1679          try: self.__field_pad 
1680          except: 
1681              self.__field_pad=UNKNOWN(**{'sizeinbytes': 124}) 
1682          return self.__field_pad.getvalue() 
1683   
1684 -    def __setfield_pad(self, value): 
1685          if isinstance(value,UNKNOWN): 
1686              self.__field_pad=value 
1687          else: 
1688              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 124}) 
1689   
1690 -    def __delfield_pad(self): del self.__field_pad 
1691   
1692      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
1693   
1694 -    def iscontainer(self): 
1695          return True 
1696   
1697 -    def containerelements(self): 
1698          yield ('header', self.__field_header, None) 
1699          yield ('slot', self.__field_slot, None) 
1700          yield ('flag', self.__field_flag, None) 
1701          yield ('pad', self.__field_pad, None) 
1702   
1703   
1704   
1705   
1706 -class eventupdaterequest(BaseProtogenClass): 
1707      __fields=['header', 'entry', 'pad'] 
1708   
1709 -    def __init__(self, *args, **kwargs): 
1710          dict={} 
1711          # What was supplied to this function 
1712          dict.update(kwargs) 
1713          # Parent constructor 
1714          super(eventupdaterequest,self).__init__(**dict) 
1715          if self.__class__ is eventupdaterequest: 
1716              self._update(args,dict) 
1717   
1718   
1719 -    def getfields(self): 
1720          return self.__fields 
1721   
1722   
1723 -    def _update(self, args, kwargs): 
1724          super(eventupdaterequest,self)._update(args,kwargs) 
1725          keys=kwargs.keys() 
1726          for key in keys: 
1727              if key in self.__fields: 
1728                  setattr(self, key, kwargs[key]) 
1729                  del kwargs[key] 
1730          # Were any unrecognized kwargs passed in? 
1731          if __debug__: 
1732              self._complainaboutunusedargs(eventupdaterequest,kwargs) 
1733          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1734          # Make all P fields that haven't already been constructed 
1735   
1736   
1737 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1738          'Writes this packet to the supplied buffer' 
1739          self._bufferstartoffset=buf.getcurrentoffset() 
1740          try: self.__field_header 
1741          except: 
1742              self.__field_header=qcpwriteheader(**{'packettype': 0x0c, 'command':0x23}) 
1743          self.__field_header.writetobuffer(buf) 
1744          self.__field_entry.writetobuffer(buf) 
1745          try: self.__field_pad 
1746          except: 
1747              self.__field_pad=UNKNOWN(**{'sizeinbytes': 56}) 
1748          self.__field_pad.writetobuffer(buf) 
1749          self._bufferendoffset=buf.getcurrentoffset() 
1750          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1751   
1752   
1753 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1754          'Reads this packet from the supplied buffer' 
1755          self._bufferstartoffset=buf.getcurrentoffset() 
1756          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1757          self.__field_header=qcpwriteheader(**{'packettype': 0x0c, 'command':0x23}) 
1758          self.__field_header.readfrombuffer(buf) 
1759          self.__field_entry=evententry() 
1760          self.__field_entry.readfrombuffer(buf) 
1761          self.__field_pad=UNKNOWN(**{'sizeinbytes': 56}) 
1762          self.__field_pad.readfrombuffer(buf) 
1763          self._bufferendoffset=buf.getcurrentoffset() 
1764   
1765   
1766 -    def __getfield_header(self): 
1767          try: self.__field_header 
1768          except: 
1769              self.__field_header=qcpwriteheader(**{'packettype': 0x0c, 'command':0x23}) 
1770          return self.__field_header.getvalue() 
1771   
1772 -    def __setfield_header(self, value): 
1773          if isinstance(value,qcpwriteheader): 
1774              self.__field_header=value 
1775          else: 
1776              self.__field_header=qcpwriteheader(value,**{'packettype': 0x0c, 'command':0x23}) 
1777   
1778 -    def __delfield_header(self): del self.__field_header 
1779   
1780      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
1781   
1782 -    def __getfield_entry(self): 
1783          return self.__field_entry.getvalue() 
1784   
1785 -    def __setfield_entry(self, value): 
1786          if isinstance(value,evententry): 
1787              self.__field_entry=value 
1788          else: 
1789              self.__field_entry=evententry(value,) 
1790   
1791 -    def __delfield_entry(self): del self.__field_entry 
1792   
1793      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
1794   
1795 -    def __getfield_pad(self): 
1796          try: self.__field_pad 
1797          except: 
1798              self.__field_pad=UNKNOWN(**{'sizeinbytes': 56}) 
1799          return self.__field_pad.getvalue() 
1800   
1801 -    def __setfield_pad(self, value): 
1802          if isinstance(value,UNKNOWN): 
1803              self.__field_pad=value 
1804          else: 
1805              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 56}) 
1806   
1807 -    def __delfield_pad(self): del self.__field_pad 
1808   
1809      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
1810   
1811 -    def iscontainer(self): 
1812          return True 
1813   
1814 -    def containerelements(self): 
1815          yield ('header', self.__field_header, None) 
1816          yield ('entry', self.__field_entry, None) 
1817          yield ('pad', self.__field_pad, None) 
1818   
1819   
1820   
1821   
1822 -class callalarmrequest(BaseProtogenClass): 
1823      __fields=['header', 'slot', 'pad'] 
1824   
1825 -    def __init__(self, *args, **kwargs): 
1826          dict={} 
1827          # What was supplied to this function 
1828          dict.update(kwargs) 
1829          # Parent constructor 
1830          super(callalarmrequest,self).__init__(**dict) 
1831          if self.__class__ is callalarmrequest: 
1832              self._update(args,dict) 
1833   
1834   
1835 -    def getfields(self): 
1836          return self.__fields 
1837   
1838   
1839 -    def _update(self, args, kwargs): 
1840          super(callalarmrequest,self)._update(args,kwargs) 
1841          keys=kwargs.keys() 
1842          for key in keys: 
1843              if key in self.__fields: 
1844                  setattr(self, key, kwargs[key]) 
1845                  del kwargs[key] 
1846          # Were any unrecognized kwargs passed in? 
1847          if __debug__: 
1848              self._complainaboutunusedargs(callalarmrequest,kwargs) 
1849          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1850          # Make all P fields that haven't already been constructed 
1851   
1852   
1853 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1854          'Writes this packet to the supplied buffer' 
1855          self._bufferstartoffset=buf.getcurrentoffset() 
1856          try: self.__field_header 
1857          except: 
1858              self.__field_header=sanyoheader(**{'packettype': 0x0c,              'command': 0x24}) 
1859          self.__field_header.writetobuffer(buf) 
1860          self.__field_slot.writetobuffer(buf) 
1861          try: self.__field_pad 
1862          except: 
1863              self.__field_pad=UNKNOWN(**{'sizeinbytes': 501}) 
1864          self.__field_pad.writetobuffer(buf) 
1865          self._bufferendoffset=buf.getcurrentoffset() 
1866          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1867   
1868   
1869 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1870          'Reads this packet from the supplied buffer' 
1871          self._bufferstartoffset=buf.getcurrentoffset() 
1872          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1873          self.__field_header=sanyoheader(**{'packettype': 0x0c,          'command': 0x24}) 
1874          self.__field_header.readfrombuffer(buf) 
1875          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
1876          self.__field_slot.readfrombuffer(buf) 
1877          self.__field_pad=UNKNOWN(**{'sizeinbytes': 501}) 
1878          self.__field_pad.readfrombuffer(buf) 
1879          self._bufferendoffset=buf.getcurrentoffset() 
1880   
1881   
1882 -    def __getfield_header(self): 
1883          try: self.__field_header 
1884          except: 
1885              self.__field_header=sanyoheader(**{'packettype': 0x0c,              'command': 0x24}) 
1886          return self.__field_header.getvalue() 
1887   
1888 -    def __setfield_header(self, value): 
1889          if isinstance(value,sanyoheader): 
1890              self.__field_header=value 
1891          else: 
1892              self.__field_header=sanyoheader(value,**{'packettype': 0x0c,                'command': 0x24}) 
1893   
1894 -    def __delfield_header(self): del self.__field_header 
1895   
1896      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
1897   
1898 -    def __getfield_slot(self): 
1899          return self.__field_slot.getvalue() 
1900   
1901 -    def __setfield_slot(self, value): 
1902          if isinstance(value,UINT): 
1903              self.__field_slot=value 
1904          else: 
1905              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
1906   
1907 -    def __delfield_slot(self): del self.__field_slot 
1908   
1909      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
1910   
1911 -    def __getfield_pad(self): 
1912          try: self.__field_pad 
1913          except: 
1914              self.__field_pad=UNKNOWN(**{'sizeinbytes': 501}) 
1915          return self.__field_pad.getvalue() 
1916   
1917 -    def __setfield_pad(self, value): 
1918          if isinstance(value,UNKNOWN): 
1919              self.__field_pad=value 
1920          else: 
1921              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 501}) 
1922   
1923 -    def __delfield_pad(self): del self.__field_pad 
1924   
1925      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
1926   
1927 -    def iscontainer(self): 
1928          return True 
1929   
1930 -    def containerelements(self): 
1931          yield ('header', self.__field_header, None) 
1932          yield ('slot', self.__field_slot, None) 
1933          yield ('pad', self.__field_pad, None) 
1934   
1935   
1936   
1937   
1938 -class callalarmentry(BaseProtogenClass): 
1939      __fields=['slot', 'flag', 'dunno1', 'phonenum', 'phonenum_len', 'date', 'period', 'dom', 'datedup', 'name', 'pad1', 'name_len', 'phonenumbertype', 'phonenumberslot', 'serial', 'pad2', 'ringtone'] 
1940   
1941 -    def __init__(self, *args, **kwargs): 
1942          dict={} 
1943          # What was supplied to this function 
1944          dict.update(kwargs) 
1945          # Parent constructor 
1946          super(callalarmentry,self).__init__(**dict) 
1947          if self.__class__ is callalarmentry: 
1948              self._update(args,dict) 
1949   
1950   
1951 -    def getfields(self): 
1952          return self.__fields 
1953   
1954   
1955 -    def _update(self, args, kwargs): 
1956          super(callalarmentry,self)._update(args,kwargs) 
1957          keys=kwargs.keys() 
1958          for key in keys: 
1959              if key in self.__fields: 
1960                  setattr(self, key, kwargs[key]) 
1961                  del kwargs[key] 
1962          # Were any unrecognized kwargs passed in? 
1963          if __debug__: 
1964              self._complainaboutunusedargs(callalarmentry,kwargs) 
1965          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1966          # Make all P fields that haven't already been constructed 
1967   
1968   
1969 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1970          'Writes this packet to the supplied buffer' 
1971          self._bufferstartoffset=buf.getcurrentoffset() 
1972          self.__field_slot.writetobuffer(buf) 
1973          self.__field_flag.writetobuffer(buf) 
1974          try: self.__field_dunno1 
1975          except: 
1976              self.__field_dunno1=UINT(**{'sizeinbytes': 1, 'default': 0}) 
1977          self.__field_dunno1.writetobuffer(buf) 
1978          self.__field_phonenum.writetobuffer(buf) 
1979          self.__field_phonenum_len.writetobuffer(buf) 
1980          self.__field_date.writetobuffer(buf) 
1981          self.__field_period.writetobuffer(buf) 
1982          self.__field_dom.writetobuffer(buf) 
1983          self.__field_datedup.writetobuffer(buf) 
1984          self.__field_name.writetobuffer(buf) 
1985          try: self.__field_pad1 
1986          except: 
1987              self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1}) 
1988          self.__field_pad1.writetobuffer(buf) 
1989          self.__field_name_len.writetobuffer(buf) 
1990          self.__field_phonenumbertype.writetobuffer(buf) 
1991          self.__field_phonenumberslot.writetobuffer(buf) 
1992          try: self.__field_serial 
1993          except: 
1994              self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 
1995          self.__field_serial.writetobuffer(buf) 
1996          try: self.__field_pad2 
1997          except: 
1998              self.__field_pad2=UNKNOWN(**{'sizeinbytes': 3}) 
1999          self.__field_pad2.writetobuffer(buf) 
2000          self.__field_ringtone.writetobuffer(buf) 
2001          self._bufferendoffset=buf.getcurrentoffset() 
2002          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2003   
2004   
2005 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2006          'Reads this packet from the supplied buffer' 
2007          self._bufferstartoffset=buf.getcurrentoffset() 
2008          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2009          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
2010          self.__field_slot.readfrombuffer(buf) 
2011          self.__field_flag=UINT(**{'sizeinbytes': 1}) 
2012          self.__field_flag.readfrombuffer(buf) 
2013          self.__field_dunno1=UINT(**{'sizeinbytes': 1, 'default': 0}) 
2014          self.__field_dunno1.readfrombuffer(buf) 
2015          self.__field_phonenum=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 
2016          self.__field_phonenum.readfrombuffer(buf) 
2017          self.__field_phonenum_len=UINT(**{'sizeinbytes': 1}) 
2018          self.__field_phonenum_len.readfrombuffer(buf) 
2019          self.__field_date=UINT(**{'sizeinbytes': 4}) 
2020          self.__field_date.readfrombuffer(buf) 
2021          self.__field_period=UINT(**{'sizeinbytes': 1}) 
2022          self.__field_period.readfrombuffer(buf) 
2023          self.__field_dom=UINT(**{'sizeinbytes': 1}) 
2024          self.__field_dom.readfrombuffer(buf) 
2025          self.__field_datedup=UINT(**{'sizeinbytes': 4}) 
2026          self.__field_datedup.readfrombuffer(buf) 
2027          self.__field_name=USTRING(**{'sizeinbytes': 16, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
2028          self.__field_name.readfrombuffer(buf) 
2029          self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1}) 
2030          self.__field_pad1.readfrombuffer(buf) 
2031          self.__field_name_len=UINT(**{'sizeinbytes': 1}) 
2032          self.__field_name_len.readfrombuffer(buf) 
2033          self.__field_phonenumbertype=UINT(**{'sizeinbytes': 1}) 
2034          self.__field_phonenumbertype.readfrombuffer(buf) 
2035          self.__field_phonenumberslot=UINT(**{'sizeinbytes': 2}) 
2036          self.__field_phonenumberslot.readfrombuffer(buf) 
2037          self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 
2038          self.__field_serial.readfrombuffer(buf) 
2039          self.__field_pad2=UNKNOWN(**{'sizeinbytes': 3}) 
2040          self.__field_pad2.readfrombuffer(buf) 
2041          self.__field_ringtone=UINT(**{'sizeinbytes': 1}) 
2042          self.__field_ringtone.readfrombuffer(buf) 
2043          self._bufferendoffset=buf.getcurrentoffset() 
2044   
2045   
2046 -    def __getfield_slot(self): 
2047          return self.__field_slot.getvalue() 
2048   
2049 -    def __setfield_slot(self, value): 
2050          if isinstance(value,UINT): 
2051              self.__field_slot=value 
2052          else: 
2053              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
2054   
2055 -    def __delfield_slot(self): del self.__field_slot 
2056   
2057      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
2058   
2059 -    def __getfield_flag(self): 
2060          return self.__field_flag.getvalue() 
2061   
2062 -    def __setfield_flag(self, value): 
2063          if isinstance(value,UINT): 
2064              self.__field_flag=value 
2065          else: 
2066              self.__field_flag=UINT(value,**{'sizeinbytes': 1}) 
2067   
2068 -    def __delfield_flag(self): del self.__field_flag 
2069   
2070      flag=property(__getfield_flag, __setfield_flag, __delfield_flag, "0: Not used, 1: Scheduled, 2: Already Happened") 
2071   
2072 -    def __getfield_dunno1(self): 
2073          try: self.__field_dunno1 
2074          except: 
2075              self.__field_dunno1=UINT(**{'sizeinbytes': 1, 'default': 0}) 
2076          return self.__field_dunno1.getvalue() 
2077   
2078 -    def __setfield_dunno1(self, value): 
2079          if isinstance(value,UINT): 
2080              self.__field_dunno1=value 
2081          else: 
2082              self.__field_dunno1=UINT(value,**{'sizeinbytes': 1, 'default': 0}) 
2083   
2084 -    def __delfield_dunno1(self): del self.__field_dunno1 
2085   
2086      dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, "Related to Snooze?") 
2087   
2088 -    def __getfield_phonenum(self): 
2089          return self.__field_phonenum.getvalue() 
2090   
2091 -    def __setfield_phonenum(self, value): 
2092          if isinstance(value,USTRING): 
2093              self.__field_phonenum=value 
2094          else: 
2095              self.__field_phonenum=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 
2096   
2097 -    def __delfield_phonenum(self): del self.__field_phonenum 
2098   
2099      phonenum=property(__getfield_phonenum, __setfield_phonenum, __delfield_phonenum, None) 
2100   
2101 -    def __getfield_phonenum_len(self): 
2102          return self.__field_phonenum_len.getvalue() 
2103   
2104 -    def __setfield_phonenum_len(self, value): 
2105          if isinstance(value,UINT): 
2106              self.__field_phonenum_len=value 
2107          else: 
2108              self.__field_phonenum_len=UINT(value,**{'sizeinbytes': 1}) 
2109   
2110 -    def __delfield_phonenum_len(self): del self.__field_phonenum_len 
2111   
2112      phonenum_len=property(__getfield_phonenum_len, __setfield_phonenum_len, __delfield_phonenum_len, None) 
2113   
2114 -    def __getfield_date(self): 
2115          return self.__field_date.getvalue() 
2116   
2117 -    def __setfield_date(self, value): 
2118          if isinstance(value,UINT): 
2119              self.__field_date=value 
2120          else: 
2121              self.__field_date=UINT(value,**{'sizeinbytes': 4}) 
2122   
2123 -    def __delfield_date(self): del self.__field_date 
2124   
2125      date=property(__getfield_date, __setfield_date, __delfield_date, "# seconds since Jan 1, 1980 approximately") 
2126   
2127 -    def __getfield_period(self): 
2128          return self.__field_period.getvalue() 
2129   
2130 -    def __setfield_period(self, value): 
2131          if isinstance(value,UINT): 
2132              self.__field_period=value 
2133          else: 
2134              self.__field_period=UINT(value,**{'sizeinbytes': 1}) 
2135   
2136 -    def __delfield_period(self): del self.__field_period 
2137   
2138      period=property(__getfield_period, __setfield_period, __delfield_period, "No, Daily, Weekly, Monthly, Yearly") 
2139   
2140 -    def __getfield_dom(self): 
2141          return self.__field_dom.getvalue() 
2142   
2143 -    def __setfield_dom(self, value): 
2144          if isinstance(value,UINT): 
2145              self.__field_dom=value 
2146          else: 
2147              self.__field_dom=UINT(value,**{'sizeinbytes': 1}) 
2148   
2149 -    def __delfield_dom(self): del self.__field_dom 
2150   
2151      dom=property(__getfield_dom, __setfield_dom, __delfield_dom, "Day of month for the event") 
2152   
2153 -    def __getfield_datedup(self): 
2154          return self.__field_datedup.getvalue() 
2155   
2156 -    def __setfield_datedup(self, value): 
2157          if isinstance(value,UINT): 
2158              self.__field_datedup=value 
2159          else: 
2160              self.__field_datedup=UINT(value,**{'sizeinbytes': 4}) 
2161   
2162 -    def __delfield_datedup(self): del self.__field_datedup 
2163   
2164      datedup=property(__getfield_datedup, __setfield_datedup, __delfield_datedup, "Copy of the date.  Always the same???") 
2165   
2166 -    def __getfield_name(self): 
2167          return self.__field_name.getvalue() 
2168   
2169 -    def __setfield_name(self, value): 
2170          if isinstance(value,USTRING): 
2171              self.__field_name=value 
2172          else: 
2173              self.__field_name=USTRING(value,**{'sizeinbytes': 16, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
2174   
2175 -    def __delfield_name(self): del self.__field_name 
2176   
2177      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
2178   
2179 -    def __getfield_pad1(self): 
2180          try: self.__field_pad1 
2181          except: 
2182              self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1}) 
2183          return self.__field_pad1.getvalue() 
2184   
2185 -    def __setfield_pad1(self, value): 
2186          if isinstance(value,UNKNOWN): 
2187              self.__field_pad1=value 
2188          else: 
2189              self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 1}) 
2190   
2191 -    def __delfield_pad1(self): del self.__field_pad1 
2192   
2193      pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None) 
2194   
2195 -    def __getfield_name_len(self): 
2196          return self.__field_name_len.getvalue() 
2197   
2198 -    def __setfield_name_len(self, value): 
2199          if isinstance(value,UINT): 
2200              self.__field_name_len=value 
2201          else: 
2202              self.__field_name_len=UINT(value,**{'sizeinbytes': 1}) 
2203   
2204 -    def __delfield_name_len(self): del self.__field_name_len 
2205   
2206      name_len=property(__getfield_name_len, __setfield_name_len, __delfield_name_len, None) 
2207   
2208 -    def __getfield_phonenumbertype(self): 
2209          return self.__field_phonenumbertype.getvalue() 
2210   
2211 -    def __setfield_phonenumbertype(self, value): 
2212          if isinstance(value,UINT): 
2213              self.__field_phonenumbertype=value 
2214          else: 
2215              self.__field_phonenumbertype=UINT(value,**{'sizeinbytes': 1}) 
2216   
2217 -    def __delfield_phonenumbertype(self): del self.__field_phonenumbertype 
2218   
2219      phonenumbertype=property(__getfield_phonenumbertype, __setfield_phonenumbertype, __delfield_phonenumbertype, "1: Home, 2: Work, ...") 
2220   
2221 -    def __getfield_phonenumberslot(self): 
2222          return self.__field_phonenumberslot.getvalue() 
2223   
2224 -    def __setfield_phonenumberslot(self, value): 
2225          if isinstance(value,UINT): 
2226              self.__field_phonenumberslot=value 
2227          else: 
2228              self.__field_phonenumberslot=UINT(value,**{'sizeinbytes': 2}) 
2229   
2230 -    def __delfield_phonenumberslot(self): del self.__field_phonenumberslot 
2231   
2232      phonenumberslot=property(__getfield_phonenumberslot, __setfield_phonenumberslot, __delfield_phonenumberslot, None) 
2233   
2234 -    def __getfield_serial(self): 
2235          try: self.__field_serial 
2236          except: 
2237              self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 
2238          return self.__field_serial.getvalue() 
2239   
2240 -    def __setfield_serial(self, value): 
2241          if isinstance(value,UINT): 
2242              self.__field_serial=value 
2243          else: 
2244              self.__field_serial=UINT(value,**{'sizeinbytes': 1, 'default': 0}) 
2245   
2246 -    def __delfield_serial(self): del self.__field_serial 
2247   
2248      serial=property(__getfield_serial, __setfield_serial, __delfield_serial, None) 
2249   
2250 -    def __getfield_pad2(self): 
2251          try: self.__field_pad2 
2252          except: 
2253              self.__field_pad2=UNKNOWN(**{'sizeinbytes': 3}) 
2254          return self.__field_pad2.getvalue() 
2255   
2256 -    def __setfield_pad2(self, value): 
2257          if isinstance(value,UNKNOWN): 
2258              self.__field_pad2=value 
2259          else: 
2260              self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 3}) 
2261   
2262 -    def __delfield_pad2(self): del self.__field_pad2 
2263   
2264      pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None) 
2265   
2266 -    def __getfield_ringtone(self): 
2267          return self.__field_ringtone.getvalue() 
2268   
2269 -    def __setfield_ringtone(self, value): 
2270          if isinstance(value,UINT): 
2271              self.__field_ringtone=value 
2272          else: 
2273              self.__field_ringtone=UINT(value,**{'sizeinbytes': 1}) 
2274   
2275 -    def __delfield_ringtone(self): del self.__field_ringtone 
2276   
2277      ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 
2278   
2279 -    def iscontainer(self): 
2280          return True 
2281   
2282 -    def containerelements(self): 
2283          yield ('slot', self.__field_slot, None) 
2284          yield ('flag', self.__field_flag, "0: Not used, 1: Scheduled, 2: Already Happened") 
2285          yield ('dunno1', self.__field_dunno1, "Related to Snooze?") 
2286          yield ('phonenum', self.__field_phonenum, None) 
2287          yield ('phonenum_len', self.__field_phonenum_len, None) 
2288          yield ('date', self.__field_date, "# seconds since Jan 1, 1980 approximately") 
2289          yield ('period', self.__field_period, "No, Daily, Weekly, Monthly, Yearly") 
2290          yield ('dom', self.__field_dom, "Day of month for the event") 
2291          yield ('datedup', self.__field_datedup, "Copy of the date.  Always the same???") 
2292          yield ('name', self.__field_name, None) 
2293          yield ('pad1', self.__field_pad1, None) 
2294          yield ('name_len', self.__field_name_len, None) 
2295          yield ('phonenumbertype', self.__field_phonenumbertype, "1: Home, 2: Work, ...") 
2296          yield ('phonenumberslot', self.__field_phonenumberslot, None) 
2297          yield ('serial', self.__field_serial, None) 
2298          yield ('pad2', self.__field_pad2, None) 
2299          yield ('ringtone', self.__field_ringtone, None) 
2300   
2301   
2302   
2303   
2304 -class callalarmresponse(BaseProtogenClass): 
2305      __fields=['header', 'entry', 'pad'] 
2306   
2307 -    def __init__(self, *args, **kwargs): 
2308          dict={} 
2309          # What was supplied to this function 
2310          dict.update(kwargs) 
2311          # Parent constructor 
2312          super(callalarmresponse,self).__init__(**dict) 
2313          if self.__class__ is callalarmresponse: 
2314              self._update(args,dict) 
2315   
2316   
2317 -    def getfields(self): 
2318          return self.__fields 
2319   
2320   
2321 -    def _update(self, args, kwargs): 
2322          super(callalarmresponse,self)._update(args,kwargs) 
2323          keys=kwargs.keys() 
2324          for key in keys: 
2325              if key in self.__fields: 
2326                  setattr(self, key, kwargs[key]) 
2327                  del kwargs[key] 
2328          # Were any unrecognized kwargs passed in? 
2329          if __debug__: 
2330              self._complainaboutunusedargs(callalarmresponse,kwargs) 
2331          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2332          # Make all P fields that haven't already been constructed 
2333   
2334   
2335 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2336          'Writes this packet to the supplied buffer' 
2337          self._bufferstartoffset=buf.getcurrentoffset() 
2338          self.__field_header.writetobuffer(buf) 
2339          self.__field_entry.writetobuffer(buf) 
2340          self.__field_pad.writetobuffer(buf) 
2341          self._bufferendoffset=buf.getcurrentoffset() 
2342          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2343   
2344   
2345 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2346          'Reads this packet from the supplied buffer' 
2347          self._bufferstartoffset=buf.getcurrentoffset() 
2348          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2349          self.__field_header=sanyoheader() 
2350          self.__field_header.readfrombuffer(buf) 
2351          self.__field_entry=callalarmentry() 
2352          self.__field_entry.readfrombuffer(buf) 
2353          self.__field_pad=UNKNOWN(**{'sizeinbytes': 417}) 
2354          self.__field_pad.readfrombuffer(buf) 
2355          self._bufferendoffset=buf.getcurrentoffset() 
2356   
2357   
2358 -    def __getfield_header(self): 
2359          return self.__field_header.getvalue() 
2360   
2361 -    def __setfield_header(self, value): 
2362          if isinstance(value,sanyoheader): 
2363              self.__field_header=value 
2364          else: 
2365              self.__field_header=sanyoheader(value,) 
2366   
2367 -    def __delfield_header(self): del self.__field_header 
2368   
2369      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
2370   
2371 -    def __getfield_entry(self): 
2372          return self.__field_entry.getvalue() 
2373   
2374 -    def __setfield_entry(self, value): 
2375          if isinstance(value,callalarmentry): 
2376              self.__field_entry=value 
2377          else: 
2378              self.__field_entry=callalarmentry(value,) 
2379   
2380 -    def __delfield_entry(self): del self.__field_entry 
2381   
2382      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
2383   
2384 -    def __getfield_pad(self): 
2385          return self.__field_pad.getvalue() 
2386   
2387 -    def __setfield_pad(self, value): 
2388          if isinstance(value,UNKNOWN): 
2389              self.__field_pad=value 
2390          else: 
2391              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 417}) 
2392   
2393 -    def __delfield_pad(self): del self.__field_pad 
2394   
2395      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
2396   
2397 -    def iscontainer(self): 
2398          return True 
2399   
2400 -    def containerelements(self): 
2401          yield ('header', self.__field_header, None) 
2402          yield ('entry', self.__field_entry, None) 
2403          yield ('pad', self.__field_pad, None) 
2404   
2405   
2406   
2407   
2408 -class callalarmupdaterequest(BaseProtogenClass): 
2409      __fields=['header', 'entry', 'pad'] 
2410   
2411 -    def __init__(self, *args, **kwargs): 
2412          dict={} 
2413          # What was supplied to this function 
2414          dict.update(kwargs) 
2415          # Parent constructor 
2416          super(callalarmupdaterequest,self).__init__(**dict) 
2417          if self.__class__ is callalarmupdaterequest: 
2418              self._update(args,dict) 
2419   
2420   
2421 -    def getfields(self): 
2422          return self.__fields 
2423   
2424   
2425 -    def _update(self, args, kwargs): 
2426          super(callalarmupdaterequest,self)._update(args,kwargs) 
2427          keys=kwargs.keys() 
2428          for key in keys: 
2429              if key in self.__fields: 
2430                  setattr(self, key, kwargs[key]) 
2431                  del kwargs[key] 
2432          # Were any unrecognized kwargs passed in? 
2433          if __debug__: 
2434              self._complainaboutunusedargs(callalarmupdaterequest,kwargs) 
2435          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2436          # Make all P fields that haven't already been constructed 
2437   
2438   
2439 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2440          'Writes this packet to the supplied buffer' 
2441          self._bufferstartoffset=buf.getcurrentoffset() 
2442          try: self.__field_header 
2443          except: 
2444              self.__field_header=sanyowriteheader(**{'packettype': 0x0c, 'command':0x24}) 
2445          self.__field_header.writetobuffer(buf) 
2446          self.__field_entry.writetobuffer(buf) 
2447          try: self.__field_pad 
2448          except: 
2449              self.__field_pad=UNKNOWN(**{'sizeinbytes': 417}) 
2450          self.__field_pad.writetobuffer(buf) 
2451          self._bufferendoffset=buf.getcurrentoffset() 
2452          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2453   
2454   
2455 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2456          'Reads this packet from the supplied buffer' 
2457          self._bufferstartoffset=buf.getcurrentoffset() 
2458          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2459          self.__field_header=sanyowriteheader(**{'packettype': 0x0c, 'command':0x24}) 
2460          self.__field_header.readfrombuffer(buf) 
2461          self.__field_entry=callalarmentry() 
2462          self.__field_entry.readfrombuffer(buf) 
2463          self.__field_pad=UNKNOWN(**{'sizeinbytes': 417}) 
2464          self.__field_pad.readfrombuffer(buf) 
2465          self._bufferendoffset=buf.getcurrentoffset() 
2466   
2467   
2468 -    def __getfield_header(self): 
2469          try: self.__field_header 
2470          except: 
2471              self.__field_header=sanyowriteheader(**{'packettype': 0x0c, 'command':0x24}) 
2472          return self.__field_header.getvalue() 
2473   
2474 -    def __setfield_header(self, value): 
2475          if isinstance(value,sanyowriteheader): 
2476              self.__field_header=value 
2477          else: 
2478              self.__field_header=sanyowriteheader(value,**{'packettype': 0x0c, 'command':0x24}) 
2479   
2480 -    def __delfield_header(self): del self.__field_header 
2481   
2482      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
2483   
2484 -    def __getfield_entry(self): 
2485          return self.__field_entry.getvalue() 
2486   
2487 -    def __setfield_entry(self, value): 
2488          if isinstance(value,callalarmentry): 
2489              self.__field_entry=value 
2490          else: 
2491              self.__field_entry=callalarmentry(value,) 
2492   
2493 -    def __delfield_entry(self): del self.__field_entry 
2494   
2495      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
2496   
2497 -    def __getfield_pad(self): 
2498          try: self.__field_pad 
2499          except: 
2500              self.__field_pad=UNKNOWN(**{'sizeinbytes': 417}) 
2501          return self.__field_pad.getvalue() 
2502   
2503 -    def __setfield_pad(self, value): 
2504          if isinstance(value,UNKNOWN): 
2505              self.__field_pad=value 
2506          else: 
2507              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 417}) 
2508   
2509 -    def __delfield_pad(self): del self.__field_pad 
2510   
2511      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
2512   
2513 -    def iscontainer(self): 
2514          return True 
2515   
2516 -    def containerelements(self): 
2517          yield ('header', self.__field_header, None) 
2518          yield ('entry', self.__field_entry, None) 
2519          yield ('pad', self.__field_pad, None) 
2520   
2521   
2522   
2523   
2524 -class bufferpartrequest(BaseProtogenClass): 
2525      __fields=['bufpartsize', 'header', 'pad'] 
2526   
2527 -    def __init__(self, *args, **kwargs): 
2528          dict={} 
2529          # What was supplied to this function 
2530          dict.update(kwargs) 
2531          # Parent constructor 
2532          super(bufferpartrequest,self).__init__(**dict) 
2533          if self.__class__ is bufferpartrequest: 
2534              self._update(args,dict) 
2535   
2536   
2537 -    def getfields(self): 
2538          return self.__fields 
2539   
2540   
2541 -    def _update(self, args, kwargs): 
2542          super(bufferpartrequest,self)._update(args,kwargs) 
2543          keys=kwargs.keys() 
2544          for key in keys: 
2545              if key in self.__fields: 
2546                  setattr(self, key, kwargs[key]) 
2547                  del kwargs[key] 
2548          # Were any unrecognized kwargs passed in? 
2549          if __debug__: 
2550              self._complainaboutunusedargs(bufferpartrequest,kwargs) 
2551          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2552          # Make all P fields that haven't already been constructed 
2553          try: self.__field_bufpartsize 
2554          except: 
2555              self.__field_bufpartsize=UINT(**{'constant': 1024}) 
2556   
2557   
2558 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2559          'Writes this packet to the supplied buffer' 
2560          self._bufferstartoffset=buf.getcurrentoffset() 
2561          try: self.__field_header 
2562          except: 
2563              self.__field_header=sanyoheader(**{'packettype': 0x0f}) 
2564          self.__field_header.writetobuffer(buf) 
2565          try: self.__field_pad 
2566          except: 
2567              self.__field_pad=UNKNOWN(**{'sizeinbytes': 1026}) 
2568          self.__field_pad.writetobuffer(buf) 
2569          self._bufferendoffset=buf.getcurrentoffset() 
2570          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2571   
2572   
2573 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2574          'Reads this packet from the supplied buffer' 
2575          self._bufferstartoffset=buf.getcurrentoffset() 
2576          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2577          self.__field_header=sanyoheader(**{'packettype': 0x0f}) 
2578          self.__field_header.readfrombuffer(buf) 
2579          self.__field_pad=UNKNOWN(**{'sizeinbytes': 1026}) 
2580          self.__field_pad.readfrombuffer(buf) 
2581          self._bufferendoffset=buf.getcurrentoffset() 
2582   
2583   
2584 -    def __getfield_bufpartsize(self): 
2585          return self.__field_bufpartsize.getvalue() 
2586   
2587 -    def __setfield_bufpartsize(self, value): 
2588          if isinstance(value,UINT): 
2589              self.__field_bufpartsize=value 
2590          else: 
2591              self.__field_bufpartsize=UINT(value,**{'constant': 1024}) 
2592   
2593 -    def __delfield_bufpartsize(self): del self.__field_bufpartsize 
2594   
2595      bufpartsize=property(__getfield_bufpartsize, __setfield_bufpartsize, __delfield_bufpartsize, None) 
2596   
2597 -    def __getfield_header(self): 
2598          try: self.__field_header 
2599          except: 
2600              self.__field_header=sanyoheader(**{'packettype': 0x0f}) 
2601          return self.__field_header.getvalue() 
2602   
2603 -    def __setfield_header(self, value): 
2604          if isinstance(value,sanyoheader): 
2605              self.__field_header=value 
2606          else: 
2607              self.__field_header=sanyoheader(value,**{'packettype': 0x0f}) 
2608   
2609 -    def __delfield_header(self): del self.__field_header 
2610   
2611      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
2612   
2613 -    def __getfield_pad(self): 
2614          try: self.__field_pad 
2615          except: 
2616              self.__field_pad=UNKNOWN(**{'sizeinbytes': 1026}) 
2617          return self.__field_pad.getvalue() 
2618   
2619 -    def __setfield_pad(self, value): 
2620          if isinstance(value,UNKNOWN): 
2621              self.__field_pad=value 
2622          else: 
2623              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 1026}) 
2624   
2625 -    def __delfield_pad(self): del self.__field_pad 
2626   
2627      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
2628   
2629 -    def iscontainer(self): 
2630          return True 
2631   
2632 -    def containerelements(self): 
2633          yield ('bufpartsize', self.__field_bufpartsize, None) 
2634          yield ('header', self.__field_header, None) 
2635          yield ('pad', self.__field_pad, None) 
2636   
2637   
2638   
2639   
2640 -class bufferpartresponse(BaseProtogenClass): 
2641      __fields=['bufpartsize', 'header', 'data', 'pad'] 
2642   
2643 -    def __init__(self, *args, **kwargs): 
2644          dict={} 
2645          # What was supplied to this function 
2646          dict.update(kwargs) 
2647          # Parent constructor 
2648          super(bufferpartresponse,self).__init__(**dict) 
2649          if self.__class__ is bufferpartresponse: 
2650              self._update(args,dict) 
2651   
2652   
2653 -    def getfields(self): 
2654          return self.__fields 
2655   
2656   
2657 -    def _update(self, args, kwargs): 
2658          super(bufferpartresponse,self)._update(args,kwargs) 
2659          keys=kwargs.keys() 
2660          for key in keys: 
2661              if key in self.__fields: 
2662                  setattr(self, key, kwargs[key]) 
2663                  del kwargs[key] 
2664          # Were any unrecognized kwargs passed in? 
2665          if __debug__: 
2666              self._complainaboutunusedargs(bufferpartresponse,kwargs) 
2667          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2668          # Make all P fields that haven't already been constructed 
2669          try: self.__field_bufpartsize 
2670          except: 
2671              self.__field_bufpartsize=UINT(**{'constant': 1024}) 
2672   
2673   
2674 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2675          'Writes this packet to the supplied buffer' 
2676          self._bufferstartoffset=buf.getcurrentoffset() 
2677          self.__field_header.writetobuffer(buf) 
2678          self.__field_data.writetobuffer(buf) 
2679          self.__field_pad.writetobuffer(buf) 
2680          self._bufferendoffset=buf.getcurrentoffset() 
2681          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2682   
2683   
2684 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2685          'Reads this packet from the supplied buffer' 
2686          self._bufferstartoffset=buf.getcurrentoffset() 
2687          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2688          self.__field_header=sanyoheader() 
2689          self.__field_header.readfrombuffer(buf) 
2690          self.__field_data=DATA(**{'sizeinbytes': self.bufpartsize}) 
2691          self.__field_data.readfrombuffer(buf) 
2692          self.__field_pad=UNKNOWN(**{'sizeinbytes': 2}) 
2693          self.__field_pad.readfrombuffer(buf) 
2694          self._bufferendoffset=buf.getcurrentoffset() 
2695   
2696   
2697 -    def __getfield_bufpartsize(self): 
2698          return self.__field_bufpartsize.getvalue() 
2699   
2700 -    def __setfield_bufpartsize(self, value): 
2701          if isinstance(value,UINT): 
2702              self.__field_bufpartsize=value 
2703          else: 
2704              self.__field_bufpartsize=UINT(value,**{'constant': 1024}) 
2705   
2706 -    def __delfield_bufpartsize(self): del self.__field_bufpartsize 
2707   
2708      bufpartsize=property(__getfield_bufpartsize, __setfield_bufpartsize, __delfield_bufpartsize, None) 
2709   
2710 -    def __getfield_header(self): 
2711          return self.__field_header.getvalue() 
2712   
2713 -    def __setfield_header(self, value): 
2714          if isinstance(value,sanyoheader): 
2715              self.__field_header=value 
2716          else: 
2717              self.__field_header=sanyoheader(value,) 
2718   
2719 -    def __delfield_header(self): del self.__field_header 
2720   
2721      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
2722   
2723 -    def __getfield_data(self): 
2724          return self.__field_data.getvalue() 
2725   
2726 -    def __setfield_data(self, value): 
2727          if isinstance(value,DATA): 
2728              self.__field_data=value 
2729          else: 
2730              self.__field_data=DATA(value,**{'sizeinbytes': self.bufpartsize}) 
2731   
2732 -    def __delfield_data(self): del self.__field_data 
2733   
2734      data=property(__getfield_data, __setfield_data, __delfield_data, None) 
2735   
2736 -    def __getfield_pad(self): 
2737          return self.__field_pad.getvalue() 
2738   
2739 -    def __setfield_pad(self, value): 
2740          if isinstance(value,UNKNOWN): 
2741              self.__field_pad=value 
2742          else: 
2743              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 2}) 
2744   
2745 -    def __delfield_pad(self): del self.__field_pad 
2746   
2747      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
2748   
2749 -    def iscontainer(self): 
2750          return True 
2751   
2752 -    def containerelements(self): 
2753          yield ('bufpartsize', self.__field_bufpartsize, None) 
2754          yield ('header', self.__field_header, None) 
2755          yield ('data', self.__field_data, None) 
2756          yield ('pad', self.__field_pad, None) 
2757   
2758   
2759   
2760   
2761 -class bufferpartupdaterequest(BaseProtogenClass): 
2762      __fields=['bufpartsize', 'header', 'data', 'pad'] 
2763   
2764 -    def __init__(self, *args, **kwargs): 
2765          dict={} 
2766          # What was supplied to this function 
2767          dict.update(kwargs) 
2768          # Parent constructor 
2769          super(bufferpartupdaterequest,self).__init__(**dict) 
2770          if self.__class__ is bufferpartupdaterequest: 
2771              self._update(args,dict) 
2772   
2773   
2774 -    def getfields(self): 
2775          return self.__fields 
2776   
2777   
2778 -    def _update(self, args, kwargs): 
2779          super(bufferpartupdaterequest,self)._update(args,kwargs) 
2780          keys=kwargs.keys() 
2781          for key in keys: 
2782              if key in self.__fields: 
2783                  setattr(self, key, kwargs[key]) 
2784                  del kwargs[key] 
2785          # Were any unrecognized kwargs passed in? 
2786          if __debug__: 
2787              self._complainaboutunusedargs(bufferpartupdaterequest,kwargs) 
2788          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2789          # Make all P fields that haven't already been constructed 
2790          try: self.__field_bufpartsize 
2791          except: 
2792              self.__field_bufpartsize=UINT(**{'constant': 1024}) 
2793   
2794   
2795 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2796          'Writes this packet to the supplied buffer' 
2797          self._bufferstartoffset=buf.getcurrentoffset() 
2798          try: self.__field_header 
2799          except: 
2800              self.__field_header=sanyowriteheader(**{'packettype': 0x0f}) 
2801          self.__field_header.writetobuffer(buf) 
2802          self.__field_data.writetobuffer(buf) 
2803          try: self.__field_pad 
2804          except: 
2805              self.__field_pad=UNKNOWN(**{'sizeinbytes': 2}) 
2806          self.__field_pad.writetobuffer(buf) 
2807          self._bufferendoffset=buf.getcurrentoffset() 
2808          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2809   
2810   
2811 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2812          'Reads this packet from the supplied buffer' 
2813          self._bufferstartoffset=buf.getcurrentoffset() 
2814          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2815          self.__field_header=sanyowriteheader(**{'packettype': 0x0f}) 
2816          self.__field_header.readfrombuffer(buf) 
2817          self.__field_data=DATA(**{'sizeinbytes': self.bufpartsize}) 
2818          self.__field_data.readfrombuffer(buf) 
2819          self.__field_pad=UNKNOWN(**{'sizeinbytes': 2}) 
2820          self.__field_pad.readfrombuffer(buf) 
2821          self._bufferendoffset=buf.getcurrentoffset() 
2822   
2823   
2824 -    def __getfield_bufpartsize(self): 
2825          return self.__field_bufpartsize.getvalue() 
2826   
2827 -    def __setfield_bufpartsize(self, value): 
2828          if isinstance(value,UINT): 
2829              self.__field_bufpartsize=value 
2830          else: 
2831              self.__field_bufpartsize=UINT(value,**{'constant': 1024}) 
2832   
2833 -    def __delfield_bufpartsize(self): del self.__field_bufpartsize 
2834   
2835      bufpartsize=property(__getfield_bufpartsize, __setfield_bufpartsize, __delfield_bufpartsize, None) 
2836   
2837 -    def __getfield_header(self): 
2838          try: self.__field_header 
2839          except: 
2840              self.__field_header=sanyowriteheader(**{'packettype': 0x0f}) 
2841          return self.__field_header.getvalue() 
2842   
2843 -    def __setfield_header(self, value): 
2844          if isinstance(value,sanyowriteheader): 
2845              self.__field_header=value 
2846          else: 
2847              self.__field_header=sanyowriteheader(value,**{'packettype': 0x0f}) 
2848   
2849 -    def __delfield_header(self): del self.__field_header 
2850   
2851      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
2852   
2853 -    def __getfield_data(self): 
2854          return self.__field_data.getvalue() 
2855   
2856 -    def __setfield_data(self, value): 
2857          if isinstance(value,DATA): 
2858              self.__field_data=value 
2859          else: 
2860              self.__field_data=DATA(value,**{'sizeinbytes': self.bufpartsize}) 
2861   
2862 -    def __delfield_data(self): del self.__field_data 
2863   
2864      data=property(__getfield_data, __setfield_data, __delfield_data, None) 
2865   
2866 -    def __getfield_pad(self): 
2867          try: self.__field_pad 
2868          except: 
2869              self.__field_pad=UNKNOWN(**{'sizeinbytes': 2}) 
2870          return self.__field_pad.getvalue() 
2871   
2872 -    def __setfield_pad(self, value): 
2873          if isinstance(value,UNKNOWN): 
2874              self.__field_pad=value 
2875          else: 
2876              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 2}) 
2877   
2878 -    def __delfield_pad(self): del self.__field_pad 
2879   
2880      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
2881   
2882 -    def iscontainer(self): 
2883          return True 
2884   
2885 -    def containerelements(self): 
2886          yield ('bufpartsize', self.__field_bufpartsize, None) 
2887          yield ('header', self.__field_header, None) 
2888          yield ('data', self.__field_data, None) 
2889          yield ('pad', self.__field_pad, None) 
2890   
2891   
2892   
2893   
2894 -class calleridbuffer(BaseProtogenClass): 
2895      "Index so that phone can show a name instead of number" 
2896      __fields=['maxentries', 'startcommand', 'bufsize', 'comment', 'numentries', 'items', 'pad'] 
2897   
2898 -    def __init__(self, *args, **kwargs): 
2899          dict={} 
2900          # What was supplied to this function 
2901          dict.update(kwargs) 
2902          # Parent constructor 
2903          super(calleridbuffer,self).__init__(**dict) 
2904          if self.__class__ is calleridbuffer: 
2905              self._update(args,dict) 
2906   
2907   
2908 -    def getfields(self): 
2909          return self.__fields 
2910   
2911   
2912 -    def _update(self, args, kwargs): 
2913          super(calleridbuffer,self)._update(args,kwargs) 
2914          keys=kwargs.keys() 
2915          for key in keys: 
2916              if key in self.__fields: 
2917                  setattr(self, key, kwargs[key]) 
2918                  del kwargs[key] 
2919          # Were any unrecognized kwargs passed in? 
2920          if __debug__: 
2921              self._complainaboutunusedargs(calleridbuffer,kwargs) 
2922          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2923          # Make all P fields that haven't already been constructed 
2924          try: self.__field_maxentries 
2925          except: 
2926              self.__field_maxentries=UINT(**{'constant': 500}) 
2927          try: self.__field_startcommand 
2928          except: 
2929              self.__field_startcommand=UINT(**{'constant': 0x46}) 
2930          try: self.__field_bufsize 
2931          except: 
2932              self.__field_bufsize=UINT(**{'constant': 7168}) 
2933          try: self.__field_comment 
2934          except: 
2935              self.__field_comment=USTRING(**{'default': "callerid"}) 
2936   
2937   
2938 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2939          'Writes this packet to the supplied buffer' 
2940          self._bufferstartoffset=buf.getcurrentoffset() 
2941          self.__field_numentries.writetobuffer(buf) 
2942          try: self.__field_items 
2943          except: 
2944              self.__field_items=LIST(**{'length': self.maxentries, 'elementclass': calleridentry, 'createdefault': True}) 
2945          self.__field_items.writetobuffer(buf) 
2946          try: self.__field_pad 
2947          except: 
2948              self.__field_pad=UNKNOWN(**{'sizeinbytes': 666}) 
2949          self.__field_pad.writetobuffer(buf) 
2950          self._bufferendoffset=buf.getcurrentoffset() 
2951          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2952   
2953   
2954 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2955          'Reads this packet from the supplied buffer' 
2956          self._bufferstartoffset=buf.getcurrentoffset() 
2957          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2958          self.__field_numentries=UINT(**{'sizeinbytes': 2}) 
2959          self.__field_numentries.readfrombuffer(buf) 
2960          self.__field_items=LIST(**{'length': self.maxentries, 'elementclass': calleridentry, 'createdefault': True}) 
2961          self.__field_items.readfrombuffer(buf) 
2962          self.__field_pad=UNKNOWN(**{'sizeinbytes': 666}) 
2963          self.__field_pad.readfrombuffer(buf) 
2964          self._bufferendoffset=buf.getcurrentoffset() 
2965   
2966   
2967 -    def __getfield_maxentries(self): 
2968          return self.__field_maxentries.getvalue() 
2969   
2970 -    def __setfield_maxentries(self, value): 
2971          if isinstance(value,UINT): 
2972              self.__field_maxentries=value 
2973          else: 
2974              self.__field_maxentries=UINT(value,**{'constant': 500}) 
2975   
2976 -    def __delfield_maxentries(self): del self.__field_maxentries 
2977   
2978      maxentries=property(__getfield_maxentries, __setfield_maxentries, __delfield_maxentries, None) 
2979   
2980 -    def __getfield_startcommand(self): 
2981          return self.__field_startcommand.getvalue() 
2982   
2983 -    def __setfield_startcommand(self, value): 
2984          if isinstance(value,UINT): 
2985              self.__field_startcommand=value 
2986          else: 
2987              self.__field_startcommand=UINT(value,**{'constant': 0x46}) 
2988   
2989 -    def __delfield_startcommand(self): del self.__field_startcommand 
2990   
2991      startcommand=property(__getfield_startcommand, __setfield_startcommand, __delfield_startcommand, "Starting command for R/W buf parts") 
2992   
2993 -    def __getfield_bufsize(self): 
2994          return self.__field_bufsize.getvalue() 
2995   
2996 -    def __setfield_bufsize(self, value): 
2997          if isinstance(value,UINT): 
2998              self.__field_bufsize=value 
2999          else: 
3000              self.__field_bufsize=UINT(value,**{'constant': 7168}) 
3001   
3002 -    def __delfield_bufsize(self): del self.__field_bufsize 
3003   
3004      bufsize=property(__getfield_bufsize, __setfield_bufsize, __delfield_bufsize, None) 
3005   
3006 -    def __getfield_comment(self): 
3007          try: self.__field_comment 
3008          except: 
3009              self.__field_comment=USTRING(**{'default': "callerid"}) 
3010          return self.__field_comment.getvalue() 
3011   
3012 -    def __setfield_comment(self, value): 
3013          if isinstance(value,USTRING): 
3014              self.__field_comment=value 
3015          else: 
3016              self.__field_comment=USTRING(value,**{'default': "callerid"}) 
3017   
3018 -    def __delfield_comment(self): del self.__field_comment 
3019   
3020      comment=property(__getfield_comment, __setfield_comment, __delfield_comment, None) 
3021   
3022 -    def __getfield_numentries(self): 
3023          return self.__field_numentries.getvalue() 
3024   
3025 -    def __setfield_numentries(self, value): 
3026          if isinstance(value,UINT): 
3027              self.__field_numentries=value 
3028          else: 
3029              self.__field_numentries=UINT(value,**{'sizeinbytes': 2}) 
3030   
3031 -    def __delfield_numentries(self): del self.__field_numentries 
3032   
3033      numentries=property(__getfield_numentries, __setfield_numentries, __delfield_numentries, "Number phone numbers") 
3034   
3035 -    def __getfield_items(self): 
3036          try: self.__field_items 
3037          except: 
3038              self.__field_items=LIST(**{'length': self.maxentries, 'elementclass': calleridentry, 'createdefault': True}) 
3039          return self.__field_items.getvalue() 
3040   
3041 -    def __setfield_items(self, value): 
3042          if isinstance(value,LIST): 
3043              self.__field_items=value 
3044          else: 
3045              self.__field_items=LIST(value,**{'length': self.maxentries, 'elementclass': calleridentry, 'createdefault': True}) 
3046   
3047 -    def __delfield_items(self): del self.__field_items 
3048   
3049      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
3050   
3051 -    def __getfield_pad(self): 
3052          try: self.__field_pad 
3053          except: 
3054              self.__field_pad=UNKNOWN(**{'sizeinbytes': 666}) 
3055          return self.__field_pad.getvalue() 
3056   
3057 -    def __setfield_pad(self, value): 
3058          if isinstance(value,UNKNOWN): 
3059              self.__field_pad=value 
3060          else: 
3061              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 666}) 
3062   
3063 -    def __delfield_pad(self): del self.__field_pad 
3064   
3065      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
3066   
3067 -    def iscontainer(self): 
3068          return True 
3069   
3070 -    def containerelements(self): 
3071          yield ('maxentries', self.__field_maxentries, None) 
3072          yield ('startcommand', self.__field_startcommand, "Starting command for R/W buf parts") 
3073          yield ('bufsize', self.__field_bufsize, None) 
3074          yield ('comment', self.__field_comment, None) 
3075          yield ('numentries', self.__field_numentries, "Number phone numbers") 
3076          yield ('items', self.__field_items, None) 
3077          yield ('pad', self.__field_pad, None) 
3078   
3079   
3080   
3081   
3082 -class ringerpicbuffer(BaseProtogenClass): 
3083      "Index of ringer and picture assignments" 
3084      __fields=['numpbslots', 'startcommand', 'packettype', 'bufsize', 'comment', 'ringtones', 'wallpapers', 'pad'] 
3085   
3086 -    def __init__(self, *args, **kwargs): 
3087          dict={} 
3088          # What was supplied to this function 
3089          dict.update(kwargs) 
3090          # Parent constructor 
3091          super(ringerpicbuffer,self).__init__(**dict) 
3092          if self.__class__ is ringerpicbuffer: 
3093              self._update(args,dict) 
3094   
3095   
3096 -    def getfields(self): 
3097          return self.__fields 
3098   
3099   
3100 -    def _update(self, args, kwargs): 
3101          super(ringerpicbuffer,self)._update(args,kwargs) 
3102          keys=kwargs.keys() 
3103          for key in keys: 
3104              if key in self.__fields: 
3105                  setattr(self, key, kwargs[key]) 
3106                  del kwargs[key] 
3107          # Were any unrecognized kwargs passed in? 
3108          if __debug__: 
3109              self._complainaboutunusedargs(ringerpicbuffer,kwargs) 
3110          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
3111          # Make all P fields that haven't already been constructed 
3112          try: self.__field_numpbslots 
3113          except: 
3114              self.__field_numpbslots=UINT(**{'constant': _NUMPBSLOTS}) 
3115          try: self.__field_startcommand 
3116          except: 
3117              self.__field_startcommand=UINT(**{'constant': 0xd7}) 
3118          try: self.__field_packettype 
3119          except: 
3120              self.__field_packettype=UINT(**{'constant': 0x0f}) 
3121          try: self.__field_bufsize 
3122          except: 
3123              self.__field_bufsize=UINT(**{'constant': 1024}) 
3124          try: self.__field_comment 
3125          except: 
3126              self.__field_comment=USTRING(**{'default': "ringer/picture assignments"}) 
3127   
3128   
3129 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3130          'Writes this packet to the supplied buffer' 
3131          self._bufferstartoffset=buf.getcurrentoffset() 
3132          try: self.__field_ringtones 
3133          except: 
3134              self.__field_ringtones=LIST(**{'elementclass': _gen_p_sanyo3200_200, 'length': _NUMPBSLOTS}) 
3135          self.__field_ringtones.writetobuffer(buf) 
3136          try: self.__field_wallpapers 
3137          except: 
3138              self.__field_wallpapers=LIST(**{'elementclass': _gen_p_sanyo3200_202, 'length': _NUMPBSLOTS}) 
3139          self.__field_wallpapers.writetobuffer(buf) 
3140          try: self.__field_pad 
3141          except: 
3142              self.__field_pad=UNKNOWN(**{'sizeinbytes': 424}) 
3143          self.__field_pad.writetobuffer(buf) 
3144          self._bufferendoffset=buf.getcurrentoffset() 
3145          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3146   
3147   
3148 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3149          'Reads this packet from the supplied buffer' 
3150          self._bufferstartoffset=buf.getcurrentoffset() 
3151          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3152          self.__field_ringtones=LIST(**{'elementclass': _gen_p_sanyo3200_200, 'length': _NUMPBSLOTS}) 
3153          self.__field_ringtones.readfrombuffer(buf) 
3154          self.__field_wallpapers=LIST(**{'elementclass': _gen_p_sanyo3200_202, 'length': _NUMPBSLOTS}) 
3155          self.__field_wallpapers.readfrombuffer(buf) 
3156          self.__field_pad=UNKNOWN(**{'sizeinbytes': 424}) 
3157          self.__field_pad.readfrombuffer(buf) 
3158          self._bufferendoffset=buf.getcurrentoffset() 
3159   
3160   
3161 -    def __getfield_numpbslots(self): 
3162          return self.__field_numpbslots.getvalue() 
3163   
3164 -    def __setfield_numpbslots(self, value): 
3165          if isinstance(value,UINT): 
3166              self.__field_numpbslots=value 
3167          else: 
3168              self.__field_numpbslots=UINT(value,**{'constant': _NUMPBSLOTS}) 
3169   
3170 -    def __delfield_numpbslots(self): del self.__field_numpbslots 
3171   
3172      numpbslots=property(__getfield_numpbslots, __setfield_numpbslots, __delfield_numpbslots, "Number of phone book slots") 
3173   
3174 -    def __getfield_startcommand(self): 
3175          return self.__field_startcommand.getvalue() 
3176   
3177 -    def __setfield_startcommand(self, value): 
3178          if isinstance(value,UINT): 
3179              self.__field_startcommand=value 
3180          else: 
3181              self.__field_startcommand=UINT(value,**{'constant': 0xd7}) 
3182   
3183 -    def __delfield_startcommand(self): del self.__field_startcommand 
3184   
3185      startcommand=property(__getfield_startcommand, __setfield_startcommand, __delfield_startcommand, "Starting command for R/W buf parts") 
3186   
3187 -    def __getfield_packettype(self): 
3188          return self.__field_packettype.getvalue() 
3189   
3190 -    def __setfield_packettype(self, value): 
3191          if isinstance(value,UINT): 
3192              self.__field_packettype=value 
3193          else: 
3194              self.__field_packettype=UINT(value,**{'constant': 0x0f}) 
3195   
3196 -    def __delfield_packettype(self): del self.__field_packettype 
3197   
3198      packettype=property(__getfield_packettype, __setfield_packettype, __delfield_packettype, "Non standard packet type") 
3199   
3200 -    def __getfield_bufsize(self): 
3201          return self.__field_bufsize.getvalue() 
3202   
3203 -    def __setfield_bufsize(self, value): 
3204          if isinstance(value,UINT): 
3205              self.__field_bufsize=value 
3206          else: 
3207              self.__field_bufsize=UINT(value,**{'constant': 1024}) 
3208   
3209 -    def __delfield_bufsize(self): del self.__field_bufsize 
3210   
3211      bufsize=property(__getfield_bufsize, __setfield_bufsize, __delfield_bufsize, None) 
3212   
3213 -    def __getfield_comment(self): 
3214          try: self.__field_comment 
3215          except: 
3216              self.__field_comment=USTRING(**{'default': "ringer/picture assignments"}) 
3217          return self.__field_comment.getvalue() 
3218   
3219 -    def __setfield_comment(self, value): 
3220          if isinstance(value,USTRING): 
3221              self.__field_comment=value 
3222          else: 
3223              self.__field_comment=USTRING(value,**{'default': "ringer/picture assignments"}) 
3224   
3225 -    def __delfield_comment(self): del self.__field_comment 
3226   
3227      comment=property(__getfield_comment, __setfield_comment, __delfield_comment, None) 
3228   
3229 -    def __getfield_ringtones(self): 
3230          try: self.__field_ringtones 
3231          except: 
3232              self.__field_ringtones=LIST(**{'elementclass': _gen_p_sanyo3200_200, 'length': _NUMPBSLOTS}) 
3233          return self.__field_ringtones.getvalue() 
3234   
3235 -    def __setfield_ringtones(self, value): 
3236          if isinstance(value,LIST): 
3237              self.__field_ringtones=value 
3238          else: 
3239              self.__field_ringtones=LIST(value,**{'elementclass': _gen_p_sanyo3200_200, 'length': _NUMPBSLOTS}) 
3240   
3241 -    def __delfield_ringtones(self): del self.__field_ringtones 
3242   
3243      ringtones=property(__getfield_ringtones, __setfield_ringtones, __delfield_ringtones, None) 
3244   
3245 -    def __getfield_wallpapers(self): 
3246          try: self.__field_wallpapers 
3247          except: 
3248              self.__field_wallpapers=LIST(**{'elementclass': _gen_p_sanyo3200_202, 'length': _NUMPBSLOTS}) 
3249          return self.__field_wallpapers.getvalue() 
3250   
3251 -    def __setfield_wallpapers(self, value): 
3252          if isinstance(value,LIST): 
3253              self.__field_wallpapers=value 
3254          else: 
3255              self.__field_wallpapers=LIST(value,**{'elementclass': _gen_p_sanyo3200_202, 'length': _NUMPBSLOTS}) 
3256   
3257 -    def __delfield_wallpapers(self): del self.__field_wallpapers 
3258   
3259      wallpapers=property(__getfield_wallpapers, __setfield_wallpapers, __delfield_wallpapers, None) 
3260   
3261 -    def __getfield_pad(self): 
3262          try: self.__field_pad 
3263          except: 
3264              self.__field_pad=UNKNOWN(**{'sizeinbytes': 424}) 
3265          return self.__field_pad.getvalue() 
3266   
3267 -    def __setfield_pad(self, value): 
3268          if isinstance(value,UNKNOWN): 
3269              self.__field_pad=value 
3270          else: 
3271              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 424}) 
3272   
3273 -    def __delfield_pad(self): del self.__field_pad 
3274   
3275      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
3276   
3277 -    def iscontainer(self): 
3278          return True 
3279   
3280 -    def containerelements(self): 
3281          yield ('numpbslots', self.__field_numpbslots, "Number of phone book slots") 
3282          yield ('startcommand', self.__field_startcommand, "Starting command for R/W buf parts") 
3283          yield ('packettype', self.__field_packettype, "Non standard packet type") 
3284          yield ('bufsize', self.__field_bufsize, None) 
3285          yield ('comment', self.__field_comment, None) 
3286          yield ('ringtones', self.__field_ringtones, None) 
3287          yield ('wallpapers', self.__field_wallpapers, None) 
3288          yield ('pad', self.__field_pad, None) 
3289   
3290   
3291   
3292   
3293 -class _gen_p_sanyo3200_200(BaseProtogenClass): 
3294      'Anonymous inner class' 
3295      __fields=['ringtone'] 
3296   
3297 -    def __init__(self, *args, **kwargs): 
3298          dict={} 
3299          # What was supplied to this function 
3300          dict.update(kwargs) 
3301          # Parent constructor 
3302          super(_gen_p_sanyo3200_200,self).__init__(**dict) 
3303          if self.__class__ is _gen_p_sanyo3200_200: 
3304              self._update(args,dict) 
3305   
3306   
3307 -    def getfields(self): 
3308          return self.__fields 
3309   
3310   
3311 -    def _update(self, args, kwargs): 
3312          super(_gen_p_sanyo3200_200,self)._update(args,kwargs) 
3313          keys=kwargs.keys() 
3314          for key in keys: 
3315              if key in self.__fields: 
3316                  setattr(self, key, kwargs[key]) 
3317                  del kwargs[key] 
3318          # Were any unrecognized kwargs passed in? 
3319          if __debug__: 
3320              self._complainaboutunusedargs(_gen_p_sanyo3200_200,kwargs) 
3321          if len(args): 
3322              dict2={'sizeinbytes': 1} 
3323              dict2.update(kwargs) 
3324              kwargs=dict2 
3325              self.__field_ringtone=UINT(*args,**dict2) 
3326          # Make all P fields that haven't already been constructed 
3327   
3328   
3329 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3330          'Writes this packet to the supplied buffer' 
3331          self._bufferstartoffset=buf.getcurrentoffset() 
3332          self.__field_ringtone.writetobuffer(buf) 
3333          self._bufferendoffset=buf.getcurrentoffset() 
3334          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3335   
3336   
3337 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3338          'Reads this packet from the supplied buffer' 
3339          self._bufferstartoffset=buf.getcurrentoffset() 
3340          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3341          self.__field_ringtone=UINT(**{'sizeinbytes': 1}) 
3342          self.__field_ringtone.readfrombuffer(buf) 
3343          self._bufferendoffset=buf.getcurrentoffset() 
3344   
3345   
3346 -    def __getfield_ringtone(self): 
3347          return self.__field_ringtone.getvalue() 
3348   
3349 -    def __setfield_ringtone(self, value): 
3350          if isinstance(value,UINT): 
3351              self.__field_ringtone=value 
3352          else: 
3353              self.__field_ringtone=UINT(value,**{'sizeinbytes': 1}) 
3354   
3355 -    def __delfield_ringtone(self): del self.__field_ringtone 
3356   
3357      ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, "ringtone index") 
3358   
3359 -    def iscontainer(self): 
3360          return True 
3361   
3362 -    def containerelements(self): 
3363          yield ('ringtone', self.__field_ringtone, "ringtone index") 
3364   
3365   
3366   
3367   
3368 -class _gen_p_sanyo3200_202(BaseProtogenClass): 
3369      'Anonymous inner class' 
3370      __fields=['wallpaper'] 
3371   
3372 -    def __init__(self, *args, **kwargs): 
3373          dict={} 
3374          # What was supplied to this function 
3375          dict.update(kwargs) 
3376          # Parent constructor 
3377          super(_gen_p_sanyo3200_202,self).__init__(**dict) 
3378          if self.__class__ is _gen_p_sanyo3200_202: 
3379              self._update(args,dict) 
3380   
3381   
3382 -    def getfields(self): 
3383          return self.__fields 
3384   
3385   
3386 -    def _update(self, args, kwargs): 
3387          super(_gen_p_sanyo3200_202,self)._update(args,kwargs) 
3388          keys=kwargs.keys() 
3389          for key in keys: 
3390              if key in self.__fields: 
3391                  setattr(self, key, kwargs[key]) 
3392                  del kwargs[key] 
3393          # Were any unrecognized kwargs passed in? 
3394          if __debug__: 
3395              self._complainaboutunusedargs(_gen_p_sanyo3200_202,kwargs) 
3396          if len(args): 
3397              dict2={'sizeinbytes': 1} 
3398              dict2.update(kwargs) 
3399              kwargs=dict2 
3400              self.__field_wallpaper=UINT(*args,**dict2) 
3401          # Make all P fields that haven't already been constructed 
3402   
3403   
3404 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3405          'Writes this packet to the supplied buffer' 
3406          self._bufferstartoffset=buf.getcurrentoffset() 
3407          self.__field_wallpaper.writetobuffer(buf) 
3408          self._bufferendoffset=buf.getcurrentoffset() 
3409          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3410   
3411   
3412 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3413          'Reads this packet from the supplied buffer' 
3414          self._bufferstartoffset=buf.getcurrentoffset() 
3415          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3416          self.__field_wallpaper=UINT(**{'sizeinbytes': 1}) 
3417          self.__field_wallpaper.readfrombuffer(buf) 
3418          self._bufferendoffset=buf.getcurrentoffset() 
3419   
3420   
3421 -    def __getfield_wallpaper(self): 
3422          return self.__field_wallpaper.getvalue() 
3423   
3424 -    def __setfield_wallpaper(self, value): 
3425          if isinstance(value,UINT): 
3426              self.__field_wallpaper=value 
3427          else: 
3428              self.__field_wallpaper=UINT(value,**{'sizeinbytes': 1}) 
3429   
3430 -    def __delfield_wallpaper(self): del self.__field_wallpaper 
3431   
3432      wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, "wallpaper index") 
3433   
3434 -    def iscontainer(self): 
3435          return True 
3436   
3437 -    def containerelements(self): 
3438          yield ('wallpaper', self.__field_wallpaper, "wallpaper index") 
3439   
3440   
3441   
3442   
3443 -class pbsortbuffer(BaseProtogenClass): 
3444      "Various arrays for sorting the phone book, speed dial, determining which" 
3445      __fields=['startcommand', 'bufsize', 'comment', 'usedflags', 'slotsused', 'slotsused2', 'numemail', 'numurl', 'firsttypes', 'sortorder', 'pbfirstletters', 'sortorder2', 'speeddialindex', 'longnumbersindex', 'emails', 'emailfirstletters', 'urls', 'urlfirstletters', 'pad'] 
3446   
3447 -    def __init__(self, *args, **kwargs): 
3448          dict={} 
3449          # What was supplied to this function 
3450          dict.update(kwargs) 
3451          # Parent constructor 
3452          super(pbsortbuffer,self).__init__(**dict) 
3453          if self.__class__ is pbsortbuffer: 
3454              self._update(args,dict) 
3455   
3456   
3457 -    def getfields(self): 
3458          return self.__fields 
3459   
3460   
3461 -    def _update(self, args, kwargs): 
3462          super(pbsortbuffer,self)._update(args,kwargs) 
3463          keys=kwargs.keys() 
3464          for key in keys: 
3465              if key in self.__fields: 
3466                  setattr(self, key, kwargs[key]) 
3467                  del kwargs[key] 
3468          # Were any unrecognized kwargs passed in? 
3469          if __debug__: 
3470              self._complainaboutunusedargs(pbsortbuffer,kwargs) 
3471          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
3472          # Make all P fields that haven't already been constructed 
3473          try: self.__field_startcommand 
3474          except: 
3475              self.__field_startcommand=UINT(**{'constant': 0x3c}) 
3476          try: self.__field_bufsize 
3477          except: 
3478              self.__field_bufsize=UINT(**{'constant': 4096}) 
3479          try: self.__field_comment 
3480          except: 
3481              self.__field_comment=USTRING(**{'default': "sort buffer"}) 
3482   
3483   
3484 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3485          'Writes this packet to the supplied buffer' 
3486          self._bufferstartoffset=buf.getcurrentoffset() 
3487          try: self.__field_usedflags 
3488          except: 
3489              self.__field_usedflags=LIST(**{'elementclass': _gen_p_sanyo3200_223, 'length': _NUMPBSLOTS, 'createdefault': True}) 
3490          self.__field_usedflags.writetobuffer(buf) 
3491          self.__field_slotsused.writetobuffer(buf) 
3492          self.__field_slotsused2.writetobuffer(buf) 
3493          self.__field_numemail.writetobuffer(buf) 
3494          self.__field_numurl.writetobuffer(buf) 
3495          try: self.__field_firsttypes 
3496          except: 
3497              self.__field_firsttypes=LIST(**{'elementclass': _gen_p_sanyo3200_229, 'length': _NUMPBSLOTS}) 
3498          self.__field_firsttypes.writetobuffer(buf) 
3499          try: self.__field_sortorder 
3500          except: 
3501              self.__field_sortorder=LIST(**{'elementclass': _gen_p_sanyo3200_231, 'length': _NUMPBSLOTS}) 
3502          self.__field_sortorder.writetobuffer(buf) 
3503          self.__field_pbfirstletters.writetobuffer(buf) 
3504          try: self.__field_sortorder2 
3505          except: 
3506              self.__field_sortorder2=LIST(**{'elementclass': _gen_p_sanyo3200_234, 'length': _NUMPBSLOTS}) 
3507          self.__field_sortorder2.writetobuffer(buf) 
3508          try: self.__field_speeddialindex 
3509          except: 
3510              self.__field_speeddialindex=LIST(**{'elementclass': _gen_p_sanyo3200_236, 'length': _NUMSPEEDDIALS}) 
3511          self.__field_speeddialindex.writetobuffer(buf) 
3512          try: self.__field_longnumbersindex 
3513          except: 
3514              self.__field_longnumbersindex=LIST(**{'elementclass': _gen_p_sanyo3200_238, 'length': _NUMLONGNUMBERS}) 
3515          self.__field_longnumbersindex.writetobuffer(buf) 
3516          try: self.__field_emails 
3517          except: 
3518              self.__field_emails=LIST(**{'elementclass': _gen_p_sanyo3200_240, 'length': _NUMPBSLOTS}) 
3519          self.__field_emails.writetobuffer(buf) 
3520          self.__field_emailfirstletters.writetobuffer(buf) 
3521          try: self.__field_urls 
3522          except: 
3523              self.__field_urls=LIST(**{'elementclass': _gen_p_sanyo3200_243, 'length': _NUMPBSLOTS}) 
3524          self.__field_urls.writetobuffer(buf) 
3525          self.__field_urlfirstletters.writetobuffer(buf) 
3526          try: self.__field_pad 
3527          except: 
3528              self.__field_pad=UNKNOWN(**{'sizeinbytes': 162}) 
3529          self.__field_pad.writetobuffer(buf) 
3530          self._bufferendoffset=buf.getcurrentoffset() 
3531          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3532   
3533   
3534 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3535          'Reads this packet from the supplied buffer' 
3536          self._bufferstartoffset=buf.getcurrentoffset() 
3537          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3538          self.__field_usedflags=LIST(**{'elementclass': _gen_p_sanyo3200_223, 'length': _NUMPBSLOTS, 'createdefault': True}) 
3539          self.__field_usedflags.readfrombuffer(buf) 
3540          self.__field_slotsused=UINT(**{'sizeinbytes': 2}) 
3541          self.__field_slotsused.readfrombuffer(buf) 
3542          self.__field_slotsused2=UINT(**{'sizeinbytes': 2}) 
3543          self.__field_slotsused2.readfrombuffer(buf) 
3544          self.__field_numemail=UINT(**{'sizeinbytes': 2}) 
3545          self.__field_numemail.readfrombuffer(buf) 
3546          self.__field_numurl=UINT(**{'sizeinbytes': 2}) 
3547          self.__field_numurl.readfrombuffer(buf) 
3548          self.__field_firsttypes=LIST(**{'elementclass': _gen_p_sanyo3200_229, 'length': _NUMPBSLOTS}) 
3549          self.__field_firsttypes.readfrombuffer(buf) 
3550          self.__field_sortorder=LIST(**{'elementclass': _gen_p_sanyo3200_231, 'length': _NUMPBSLOTS}) 
3551          self.__field_sortorder.readfrombuffer(buf) 
3552          self.__field_pbfirstletters=USTRING(**{'terminator': None, 'sizeinbytes': _NUMPBSLOTS}) 
3553          self.__field_pbfirstletters.readfrombuffer(buf) 
3554          self.__field_sortorder2=LIST(**{'elementclass': _gen_p_sanyo3200_234, 'length': _NUMPBSLOTS}) 
3555          self.__field_sortorder2.readfrombuffer(buf) 
3556          self.__field_speeddialindex=LIST(**{'elementclass': _gen_p_sanyo3200_236, 'length': _NUMSPEEDDIALS}) 
3557          self.__field_speeddialindex.readfrombuffer(buf) 
3558          self.__field_longnumbersindex=LIST(**{'elementclass': _gen_p_sanyo3200_238, 'length': _NUMLONGNUMBERS}) 
3559          self.__field_longnumbersindex.readfrombuffer(buf) 
3560          self.__field_emails=LIST(**{'elementclass': _gen_p_sanyo3200_240, 'length': _NUMPBSLOTS}) 
3561          self.__field_emails.readfrombuffer(buf) 
3562          self.__field_emailfirstletters=USTRING(**{'terminator': None, 'sizeinbytes': _NUMPBSLOTS}) 
3563          self.__field_emailfirstletters.readfrombuffer(buf) 
3564          self.__field_urls=LIST(**{'elementclass': _gen_p_sanyo3200_243, 'length': _NUMPBSLOTS}) 
3565          self.__field_urls.readfrombuffer(buf) 
3566          self.__field_urlfirstletters=USTRING(**{'terminator': None, 'sizeinbytes': _NUMPBSLOTS}) 
3567          self.__field_urlfirstletters.readfrombuffer(buf) 
3568          self.__field_pad=UNKNOWN(**{'sizeinbytes': 162}) 
3569          self.__field_pad.readfrombuffer(buf) 
3570          self._bufferendoffset=buf.getcurrentoffset() 
3571   
3572   
3573 -    def __getfield_startcommand(self): 
3574          return self.__field_startcommand.getvalue() 
3575   
3576 -    def __setfield_startcommand(self, value): 
3577          if isinstance(value,UINT): 
3578              self.__field_startcommand=value 
3579          else: 
3580              self.__field_startcommand=UINT(value,**{'constant': 0x3c}) 
3581   
3582 -    def __delfield_startcommand(self): del self.__field_startcommand 
3583   
3584      startcommand=property(__getfield_startcommand, __setfield_startcommand, __delfield_startcommand, "Starting command for R/W buf parts") 
3585   
3586 -    def __getfield_bufsize(self): 
3587          return self.__field_bufsize.getvalue() 
3588   
3589 -    def __setfield_bufsize(self, value): 
3590          if isinstance(value,UINT): 
3591              self.__field_bufsize=value 
3592          else: 
3593              self.__field_bufsize=UINT(value,**{'constant': 4096}) 
3594   
3595 -    def __delfield_bufsize(self): del self.__field_bufsize 
3596   
3597      bufsize=property(__getfield_bufsize, __setfield_bufsize, __delfield_bufsize, None) 
3598   
3599 -    def __getfield_comment(self): 
3600          try: self.__field_comment 
3601          except: 
3602              self.__field_comment=USTRING(**{'default': "sort buffer"}) 
3603          return self.__field_comment.getvalue() 
3604   
3605 -    def __setfield_comment(self, value): 
3606          if isinstance(value,USTRING): 
3607              self.__field_comment=value 
3608          else: 
3609              self.__field_comment=USTRING(value,**{'default': "sort buffer"}) 
3610   
3611 -    def __delfield_comment(self): del self.__field_comment 
3612   
3613      comment=property(__getfield_comment, __setfield_comment, __delfield_comment, None) 
3614   
3615 -    def __getfield_usedflags(self): 
3616          try: self.__field_usedflags 
3617          except: 
3618              self.__field_usedflags=LIST(**{'elementclass': _gen_p_sanyo3200_223, 'length': _NUMPBSLOTS, 'createdefault': True}) 
3619          return self.__field_usedflags.getvalue() 
3620   
3621 -    def __setfield_usedflags(self, value): 
3622          if isinstance(value,LIST): 
3623              self.__field_usedflags=value 
3624          else: 
3625              self.__field_usedflags=LIST(value,**{'elementclass': _gen_p_sanyo3200_223, 'length': _NUMPBSLOTS, 'createdefault': True}) 
3626   
3627 -    def __delfield_usedflags(self): del self.__field_usedflags 
3628   
3629      usedflags=property(__getfield_usedflags, __setfield_usedflags, __delfield_usedflags, None) 
3630   
3631 -    def __getfield_slotsused(self): 
3632          return self.__field_slotsused.getvalue() 
3633   
3634 -    def __setfield_slotsused(self, value): 
3635          if isinstance(value,UINT): 
3636              self.__field_slotsused=value 
3637          else: 
3638              self.__field_slotsused=UINT(value,**{'sizeinbytes': 2}) 
3639   
3640 -    def __delfield_slotsused(self): del self.__field_slotsused 
3641   
3642      slotsused=property(__getfield_slotsused, __setfield_slotsused, __delfield_slotsused, None) 
3643   
3644 -    def __getfield_slotsused2(self): 
3645          return self.__field_slotsused2.getvalue() 
3646   
3647 -    def __setfield_slotsused2(self, value): 
3648          if isinstance(value,UINT): 
3649              self.__field_slotsused2=value 
3650          else: 
3651              self.__field_slotsused2=UINT(value,**{'sizeinbytes': 2}) 
3652   
3653 -    def __delfield_slotsused2(self): del self.__field_slotsused2 
3654   
3655      slotsused2=property(__getfield_slotsused2, __setfield_slotsused2, __delfield_slotsused2, "Always seems to be the same.  Why duplicated?") 
3656   
3657 -    def __getfield_numemail(self): 
3658          return self.__field_numemail.getvalue() 
3659   
3660 -    def __setfield_numemail(self, value): 
3661          if isinstance(value,UINT): 
3662              self.__field_numemail=value 
3663          else: 
3664              self.__field_numemail=UINT(value,**{'sizeinbytes': 2}) 
3665   
3666 -    def __delfield_numemail(self): del self.__field_numemail 
3667   
3668      numemail=property(__getfield_numemail, __setfield_numemail, __delfield_numemail, "Num of slots with email") 
3669   
3670 -    def __getfield_numurl(self): 
3671          return self.__field_numurl.getvalue() 
3672   
3673 -    def __setfield_numurl(self, value): 
3674          if isinstance(value,UINT): 
3675              self.__field_numurl=value 
3676          else: 
3677              self.__field_numurl=UINT(value,**{'sizeinbytes': 2}) 
3678   
3679 -    def __delfield_numurl(self): del self.__field_numurl 
3680   
3681      numurl=property(__getfield_numurl, __setfield_numurl, __delfield_numurl, "Num of slots with URL") 
3682   
3683 -    def __getfield_firsttypes(self): 
3684          try: self.__field_firsttypes 
3685          except: 
3686              self.__field_firsttypes=LIST(**{'elementclass': _gen_p_sanyo3200_229, 'length': _NUMPBSLOTS}) 
3687          return self.__field_firsttypes.getvalue() 
3688   
3689 -    def __setfield_firsttypes(self, value): 
3690          if isinstance(value,LIST): 
3691              self.__field_firsttypes=value 
3692          else: 
3693              self.__field_firsttypes=LIST(value,**{'elementclass': _gen_p_sanyo3200_229, 'length': _NUMPBSLOTS}) 
3694   
3695 -    def __delfield_firsttypes(self): del self.__field_firsttypes 
3696   
3697      firsttypes=property(__getfield_firsttypes, __setfield_firsttypes, __delfield_firsttypes, None) 
3698   
3699 -    def __getfield_sortorder(self): 
3700          try: self.__field_sortorder 
3701          except: 
3702              self.__field_sortorder=LIST(**{'elementclass': _gen_p_sanyo3200_231, 'length': _NUMPBSLOTS}) 
3703          return self.__field_sortorder.getvalue() 
3704   
3705 -    def __setfield_sortorder(self, value): 
3706          if isinstance(value,LIST): 
3707              self.__field_sortorder=value 
3708          else: 
3709              self.__field_sortorder=LIST(value,**{'elementclass': _gen_p_sanyo3200_231, 'length': _NUMPBSLOTS}) 
3710   
3711 -    def __delfield_sortorder(self): del self.__field_sortorder 
3712   
3713      sortorder=property(__getfield_sortorder, __setfield_sortorder, __delfield_sortorder, None) 
3714   
3715 -    def __getfield_pbfirstletters(self): 
3716          return self.__field_pbfirstletters.getvalue() 
3717   
3718 -    def __setfield_pbfirstletters(self, value): 
3719          if isinstance(value,USTRING): 
3720              self.__field_pbfirstletters=value 
3721          else: 
3722              self.__field_pbfirstletters=USTRING(value,**{'terminator': None, 'sizeinbytes': _NUMPBSLOTS}) 
3723   
3724 -    def __delfield_pbfirstletters(self): del self.__field_pbfirstletters 
3725   
3726      pbfirstletters=property(__getfield_pbfirstletters, __setfield_pbfirstletters, __delfield_pbfirstletters, None) 
3727   
3728 -    def __getfield_sortorder2(self): 
3729          try: self.__field_sortorder2 
3730          except: 
3731              self.__field_sortorder2=LIST(**{'elementclass': _gen_p_sanyo3200_234, 'length': _NUMPBSLOTS}) 
3732          return self.__field_sortorder2.getvalue() 
3733   
3734 -    def __setfield_sortorder2(self, value): 
3735          if isinstance(value,LIST): 
3736              self.__field_sortorder2=value 
3737          else: 
3738              self.__field_sortorder2=LIST(value,**{'elementclass': _gen_p_sanyo3200_234, 'length': _NUMPBSLOTS}) 
3739   
3740 -    def __delfield_sortorder2(self): del self.__field_sortorder2 
3741   
3742      sortorder2=property(__getfield_sortorder2, __setfield_sortorder2, __delfield_sortorder2, "Is this the same") 
3743   
3744 -    def __getfield_speeddialindex(self): 
3745          try: self.__field_speeddialindex 
3746          except: 
3747              self.__field_speeddialindex=LIST(**{'elementclass': _gen_p_sanyo3200_236, 'length': _NUMSPEEDDIALS}) 
3748          return self.__field_speeddialindex.getvalue() 
3749   
3750 -    def __setfield_speeddialindex(self, value): 
3751          if isinstance(value,LIST): 
3752              self.__field_speeddialindex=value 
3753          else: 
3754              self.__field_speeddialindex=LIST(value,**{'elementclass': _gen_p_sanyo3200_236, 'length': _NUMSPEEDDIALS}) 
3755   
3756 -    def __delfield_speeddialindex(self): del self.__field_speeddialindex 
3757   
3758      speeddialindex=property(__getfield_speeddialindex, __setfield_speeddialindex, __delfield_speeddialindex, None) 
3759   
3760 -    def __getfield_longnumbersindex(self): 
3761          try: self.__field_longnumbersindex 
3762          except: 
3763              self.__field_longnumbersindex=LIST(**{'elementclass': _gen_p_sanyo3200_238, 'length': _NUMLONGNUMBERS}) 
3764          return self.__field_longnumbersindex.getvalue() 
3765   
3766 -    def __setfield_longnumbersindex(self, value): 
3767          if isinstance(value,LIST): 
3768              self.__field_longnumbersindex=value 
3769          else: 
3770              self.__field_longnumbersindex=LIST(value,**{'elementclass': _gen_p_sanyo3200_238, 'length': _NUMLONGNUMBERS}) 
3771   
3772 -    def __delfield_longnumbersindex(self): del self.__field_longnumbersindex 
3773   
3774      longnumbersindex=property(__getfield_longnumbersindex, __setfield_longnumbersindex, __delfield_longnumbersindex, None) 
3775   
3776 -    def __getfield_emails(self): 
3777          try: self.__field_emails 
3778          except: 
3779              self.__field_emails=LIST(**{'elementclass': _gen_p_sanyo3200_240, 'length': _NUMPBSLOTS}) 
3780          return self.__field_emails.getvalue() 
3781   
3782 -    def __setfield_emails(self, value): 
3783          if isinstance(value,LIST): 
3784              self.__field_emails=value 
3785          else: 
3786              self.__field_emails=LIST(value,**{'elementclass': _gen_p_sanyo3200_240, 'length': _NUMPBSLOTS}) 
3787   
3788 -    def __delfield_emails(self): del self.__field_emails 
3789   
3790      emails=property(__getfield_emails, __setfield_emails, __delfield_emails, "Sorted list of slots with Email") 
3791   
3792 -    def __getfield_emailfirstletters(self): 
3793          return self.__field_emailfirstletters.getvalue() 
3794   
3795 -    def __setfield_emailfirstletters(self, value): 
3796          if isinstance(value,USTRING): 
3797              self.__field_emailfirstletters=value 
3798          else: 
3799              self.__field_emailfirstletters=USTRING(value,**{'terminator': None, 'sizeinbytes': _NUMPBSLOTS}) 
3800   
3801 -    def __delfield_emailfirstletters(self): del self.__field_emailfirstletters 
3802   
3803      emailfirstletters=property(__getfield_emailfirstletters, __setfield_emailfirstletters, __delfield_emailfirstletters, "First letters in sort order") 
3804   
3805 -    def __getfield_urls(self): 
3806          try: self.__field_urls 
3807          except: 
3808              self.__field_urls=LIST(**{'elementclass': _gen_p_sanyo3200_243, 'length': _NUMPBSLOTS}) 
3809          return self.__field_urls.getvalue() 
3810   
3811 -    def __setfield_urls(self, value): 
3812          if isinstance(value,LIST): 
3813              self.__field_urls=value 
3814          else: 
3815              self.__field_urls=LIST(value,**{'elementclass': _gen_p_sanyo3200_243, 'length': _NUMPBSLOTS}) 
3816   
3817 -    def __delfield_urls(self): del self.__field_urls 
3818   
3819      urls=property(__getfield_urls, __setfield_urls, __delfield_urls, "Sorted list of slots with a URL") 
3820   
3821 -    def __getfield_urlfirstletters(self): 
3822          return self.__field_urlfirstletters.getvalue() 
3823   
3824 -    def __setfield_urlfirstletters(self, value): 
3825          if isinstance(value,USTRING): 
3826              self.__field_urlfirstletters=value 
3827          else: 
3828              self.__field_urlfirstletters=USTRING(value,**{'terminator': None, 'sizeinbytes': _NUMPBSLOTS}) 
3829   
3830 -    def __delfield_urlfirstletters(self): del self.__field_urlfirstletters 
3831   
3832      urlfirstletters=property(__getfield_urlfirstletters, __setfield_urlfirstletters, __delfield_urlfirstletters, "First letters in sort order") 
3833   
3834 -    def __getfield_pad(self): 
3835          try: self.__field_pad 
3836          except: 
3837              self.__field_pad=UNKNOWN(**{'sizeinbytes': 162}) 
3838          return self.__field_pad.getvalue() 
3839   
3840 -    def __setfield_pad(self, value): 
3841          if isinstance(value,UNKNOWN): 
3842              self.__field_pad=value 
3843          else: 
3844              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 162}) 
3845   
3846 -    def __delfield_pad(self): del self.__field_pad 
3847   
3848      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
3849   
3850 -    def iscontainer(self): 
3851          return True 
3852   
3853 -    def containerelements(self): 
3854          yield ('startcommand', self.__field_startcommand, "Starting command for R/W buf parts") 
3855          yield ('bufsize', self.__field_bufsize, None) 
3856          yield ('comment', self.__field_comment, None) 
3857          yield ('usedflags', self.__field_usedflags, None) 
3858          yield ('slotsused', self.__field_slotsused, None) 
3859          yield ('slotsused2', self.__field_slotsused2, "Always seems to be the same.  Why duplicated?") 
3860          yield ('numemail', self.__field_numemail, "Num of slots with email") 
3861          yield ('numurl', self.__field_numurl, "Num of slots with URL") 
3862          yield ('firsttypes', self.__field_firsttypes, None) 
3863          yield ('sortorder', self.__field_sortorder, None) 
3864          yield ('pbfirstletters', self.__field_pbfirstletters, None) 
3865          yield ('sortorder2', self.__field_sortorder2, "Is this the same") 
3866          yield ('speeddialindex', self.__field_speeddialindex, None) 
3867          yield ('longnumbersindex', self.__field_longnumbersindex, None) 
3868          yield ('emails', self.__field_emails, "Sorted list of slots with Email") 
3869          yield ('emailfirstletters', self.__field_emailfirstletters, "First letters in sort order") 
3870          yield ('urls', self.__field_urls, "Sorted list of slots with a URL") 
3871          yield ('urlfirstletters', self.__field_urlfirstletters, "First letters in sort order") 
3872          yield ('pad', self.__field_pad, None) 
3873   
3874   
3875   
3876   
3877 -class _gen_p_sanyo3200_223(BaseProtogenClass): 
3878      'Anonymous inner class' 
3879      __fields=['used'] 
3880   
3881 -    def __init__(self, *args, **kwargs): 
3882          dict={} 
3883          # What was supplied to this function 
3884          dict.update(kwargs) 
3885          # Parent constructor 
3886          super(_gen_p_sanyo3200_223,self).__init__(**dict) 
3887          if self.__class__ is _gen_p_sanyo3200_223: 
3888              self._update(args,dict) 
3889   
3890   
3891 -    def getfields(self): 
3892          return self.__fields 
3893   
3894   
3895 -    def _update(self, args, kwargs): 
3896          super(_gen_p_sanyo3200_223,self)._update(args,kwargs) 
3897          keys=kwargs.keys() 
3898          for key in keys: 
3899              if key in self.__fields: 
3900                  setattr(self, key, kwargs[key]) 
3901                  del kwargs[key] 
3902          # Were any unrecognized kwargs passed in? 
3903          if __debug__: 
3904              self._complainaboutunusedargs(_gen_p_sanyo3200_223,kwargs) 
3905          if len(args): 
3906              dict2={'sizeinbytes': 1} 
3907              dict2.update(kwargs) 
3908              kwargs=dict2 
3909              self.__field_used=UINT(*args,**dict2) 
3910          # Make all P fields that haven't already been constructed 
3911   
3912   
3913 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3914          'Writes this packet to the supplied buffer' 
3915          self._bufferstartoffset=buf.getcurrentoffset() 
3916          self.__field_used.writetobuffer(buf) 
3917          self._bufferendoffset=buf.getcurrentoffset() 
3918          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3919   
3920   
3921 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3922          'Reads this packet from the supplied buffer' 
3923          self._bufferstartoffset=buf.getcurrentoffset() 
3924          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3925          self.__field_used=UINT(**{'sizeinbytes': 1}) 
3926          self.__field_used.readfrombuffer(buf) 
3927          self._bufferendoffset=buf.getcurrentoffset() 
3928   
3929   
3930 -    def __getfield_used(self): 
3931          return self.__field_used.getvalue() 
3932   
3933 -    def __setfield_used(self, value): 
3934          if isinstance(value,UINT): 
3935              self.__field_used=value 
3936          else: 
3937              self.__field_used=UINT(value,**{'sizeinbytes': 1}) 
3938   
3939 -    def __delfield_used(self): del self.__field_used 
3940   
3941      used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 
3942   
3943 -    def iscontainer(self): 
3944          return True 
3945   
3946 -    def containerelements(self): 
3947          yield ('used', self.__field_used, "1 if slot in use") 
3948   
3949   
3950   
3951   
3952 -class _gen_p_sanyo3200_229(BaseProtogenClass): 
3953      'Anonymous inner class' 
3954      __fields=['firsttype'] 
3955   
3956 -    def __init__(self, *args, **kwargs): 
3957          dict={} 
3958          # What was supplied to this function 
3959          dict.update(kwargs) 
3960          # Parent constructor 
3961          super(_gen_p_sanyo3200_229,self).__init__(**dict) 
3962          if self.__class__ is _gen_p_sanyo3200_229: 
3963              self._update(args,dict) 
3964   
3965   
3966 -    def getfields(self): 
3967          return self.__fields 
3968   
3969   
3970 -    def _update(self, args, kwargs): 
3971          super(_gen_p_sanyo3200_229,self)._update(args,kwargs) 
3972          keys=kwargs.keys() 
3973          for key in keys: 
3974              if key in self.__fields: 
3975                  setattr(self, key, kwargs[key]) 
3976                  del kwargs[key] 
3977          # Were any unrecognized kwargs passed in? 
3978          if __debug__: 
3979              self._complainaboutunusedargs(_gen_p_sanyo3200_229,kwargs) 
3980          if len(args): 
3981              dict2={'sizeinbytes': 1} 
3982              dict2.update(kwargs) 
3983              kwargs=dict2 
3984              self.__field_firsttype=UINT(*args,**dict2) 
3985          # Make all P fields that haven't already been constructed 
3986   
3987   
3988 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3989          'Writes this packet to the supplied buffer' 
3990          self._bufferstartoffset=buf.getcurrentoffset() 
3991          self.__field_firsttype.writetobuffer(buf) 
3992          self._bufferendoffset=buf.getcurrentoffset() 
3993          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3994   
3995   
3996 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3997          'Reads this packet from the supplied buffer' 
3998          self._bufferstartoffset=buf.getcurrentoffset() 
3999          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
4000          self.__field_firsttype=UINT(**{'sizeinbytes': 1}) 
4001          self.__field_firsttype.readfrombuffer(buf) 
4002          self._bufferendoffset=buf.getcurrentoffset() 
4003   
4004   
4005 -    def __getfield_firsttype(self): 
4006          return self.__field_firsttype.getvalue() 
4007   
4008 -    def __setfield_firsttype(self, value): 
4009          if isinstance(value,UINT): 
4010              self.__field_firsttype=value 
4011          else: 
4012              self.__field_firsttype=UINT(value,**{'sizeinbytes': 1}) 
4013   
4014 -    def __delfield_firsttype(self): del self.__field_firsttype 
4015   
4016      firsttype=property(__getfield_firsttype, __setfield_firsttype, __delfield_firsttype, "First phone number type in each slot") 
4017   
4018 -    def iscontainer(self): 
4019          return True 
4020   
4021 -    def containerelements(self): 
4022          yield ('firsttype', self.__field_firsttype, "First phone number type in each slot") 
4023   
4024   
4025   
4026   
4027 -class _gen_p_sanyo3200_231(BaseProtogenClass): 
4028      'Anonymous inner class' 
4029      __fields=['pbslot'] 
4030   
4031 -    def __init__(self, *args, **kwargs): 
4032          dict={} 
4033          # What was supplied to this function 
4034          dict.update(kwargs) 
4035          # Parent constructor 
4036          super(_gen_p_sanyo3200_231,self).__init__(**dict) 
4037          if self.__class__ is _gen_p_sanyo3200_231: 
4038              self._update(args,dict) 
4039   
4040   
4041 -    def getfields(self): 
4042          return self.__fields 
4043   
4044   
4045 -    def _update(self, args, kwargs): 
4046          super(_gen_p_sanyo3200_231,self)._update(args,kwargs) 
4047          keys=kwargs.keys() 
4048          for key in keys: 
4049              if key in self.__fields: 
4050                  setattr(self, key, kwargs[key]) 
4051                  del kwargs[key] 
4052          # Were any unrecognized kwargs passed in? 
4053          if __debug__: 
4054              self._complainaboutunusedargs(_gen_p_sanyo3200_231,kwargs) 
4055          if len(args): 
4056              dict2={'sizeinbytes': 2, 'default': 0xffff} 
4057              dict2.update(kwargs) 
4058              kwargs=dict2 
4059              self.__field_pbslot=UINT(*args,**dict2) 
4060          # Make all P fields that haven't already been constructed 
4061   
4062   
4063 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
4064          'Writes this packet to the supplied buffer' 
4065          self._bufferstartoffset=buf.getcurrentoffset() 
4066          self.__field_pbslot.writetobuffer(buf) 
4067          self._bufferendoffset=buf.getcurrentoffset() 
4068          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
4069   
4070   
4071 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
4072          'Reads this packet from the supplied buffer' 
4073          self._bufferstartoffset=buf.getcurrentoffset() 
4074          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
4075          self.__field_pbslot=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
4076          self.__field_pbslot.readfrombuffer(buf) 
4077          self._bufferendoffset=buf.getcurrentoffset() 
4078   
4079   
4080 -    def __getfield_pbslot(self): 
4081          return self.__field_pbslot.getvalue() 
4082   
4083 -    def __setfield_pbslot(self, value): 
4084          if isinstance(value,UINT): 
4085              self.__field_pbslot=value 
4086          else: 
4087              self.__field_pbslot=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff}) 
4088   
4089 -    def __delfield_pbslot(self): del self.__field_pbslot 
4090   
4091      pbslot=property(__getfield_pbslot, __setfield_pbslot, __delfield_pbslot, None) 
4092   
4093 -    def iscontainer(self): 
4094          return True 
4095   
4096 -    def containerelements(self): 
4097          yield ('pbslot', self.__field_pbslot, None) 
4098   
4099   
4100   
4101   
4102 -class _gen_p_sanyo3200_234(BaseProtogenClass): 
4103      'Anonymous inner class' 
4104      __fields=['pbslot'] 
4105   
4106 -    def __init__(self, *args, **kwargs): 
4107          dict={} 
4108          # What was supplied to this function 
4109          dict.update(kwargs) 
4110          # Parent constructor 
4111          super(_gen_p_sanyo3200_234,self).__init__(**dict) 
4112          if self.__class__ is _gen_p_sanyo3200_234: 
4113              self._update(args,dict) 
4114   
4115   
4116 -    def getfields(self): 
4117          return self.__fields 
4118   
4119   
4120 -    def _update(self, args, kwargs): 
4121          super(_gen_p_sanyo3200_234,self)._update(args,kwargs) 
4122          keys=kwargs.keys() 
4123          for key in keys: 
4124              if key in self.__fields: 
4125                  setattr(self, key, kwargs[key]) 
4126                  del kwargs[key] 
4127          # Were any unrecognized kwargs passed in? 
4128          if __debug__: 
4129              self._complainaboutunusedargs(_gen_p_sanyo3200_234,kwargs) 
4130          if len(args): 
4131              dict2={'sizeinbytes': 2, 'default': 0xffff} 
4132              dict2.update(kwargs) 
4133              kwargs=dict2 
4134              self.__field_pbslot=UINT(*args,**dict2) 
4135          # Make all P fields that haven't already been constructed 
4136   
4137   
4138 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
4139          'Writes this packet to the supplied buffer' 
4140          self._bufferstartoffset=buf.getcurrentoffset() 
4141          self.__field_pbslot.writetobuffer(buf) 
4142          self._bufferendoffset=buf.getcurrentoffset() 
4143          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
4144   
4145   
4146 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
4147          'Reads this packet from the supplied buffer' 
4148          self._bufferstartoffset=buf.getcurrentoffset() 
4149          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
4150          self.__field_pbslot=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
4151          self.__field_pbslot.readfrombuffer(buf) 
4152          self._bufferendoffset=buf.getcurrentoffset() 
4153   
4154   
4155 -    def __getfield_pbslot(self): 
4156          return self.__field_pbslot.getvalue() 
4157   
4158 -    def __setfield_pbslot(self, value): 
4159          if isinstance(value,UINT): 
4160              self.__field_pbslot=value 
4161          else: 
4162              self.__field_pbslot=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff}) 
4163   
4164 -    def __delfield_pbslot(self): del self.__field_pbslot 
4165   
4166      pbslot=property(__getfield_pbslot, __setfield_pbslot, __delfield_pbslot, None) 
4167   
4168 -    def iscontainer(self): 
4169          return True 
4170   
4171 -    def containerelements(self): 
4172          yield ('pbslot', self.__field_pbslot, None) 
4173   
4174   
4175   
4176   
4177 -class _gen_p_sanyo3200_236(BaseProtogenClass): 
4178      'Anonymous inner class' 
4179      __fields=['pbslotandtype'] 
4180   
4181 -    def __init__(self, *args, **kwargs): 
4182          dict={} 
4183          # What was supplied to this function 
4184          dict.update(kwargs) 
4185          # Parent constructor 
4186          super(_gen_p_sanyo3200_236,self).__init__(**dict) 
4187          if self.__class__ is _gen_p_sanyo3200_236: 
4188              self._update(args,dict) 
4189   
4190   
4191 -    def getfields(self): 
4192          return self.__fields 
4193   
4194   
4195 -    def _update(self, args, kwargs): 
4196          super(_gen_p_sanyo3200_236,self)._update(args,kwargs) 
4197          keys=kwargs.keys() 
4198          for key in keys: 
4199              if key in self.__fields: 
4200                  setattr(self, key, kwargs[key]) 
4201                  del kwargs[key] 
4202          # Were any unrecognized kwargs passed in? 
4203          if __debug__: 
4204              self._complainaboutunusedargs(_gen_p_sanyo3200_236,kwargs) 
4205          if len(args): 
4206              dict2={'sizeinbytes': 2, 'default': 0xffff} 
4207              dict2.update(kwargs) 
4208              kwargs=dict2 
4209              self.__field_pbslotandtype=UINT(*args,**dict2) 
4210          # Make all P fields that haven't already been constructed 
4211   
4212   
4213 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
4214          'Writes this packet to the supplied buffer' 
4215          self._bufferstartoffset=buf.getcurrentoffset() 
4216          self.__field_pbslotandtype.writetobuffer(buf) 
4217          self._bufferendoffset=buf.getcurrentoffset() 
4218          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
4219   
4220   
4221 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
4222          'Reads this packet from the supplied buffer' 
4223          self._bufferstartoffset=buf.getcurrentoffset() 
4224          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
4225          self.__field_pbslotandtype=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
4226          self.__field_pbslotandtype.readfrombuffer(buf) 
4227          self._bufferendoffset=buf.getcurrentoffset() 
4228   
4229   
4230 -    def __getfield_pbslotandtype(self): 
4231          return self.__field_pbslotandtype.getvalue() 
4232   
4233 -    def __setfield_pbslotandtype(self, value): 
4234          if isinstance(value,UINT): 
4235              self.__field_pbslotandtype=value 
4236          else: 
4237              self.__field_pbslotandtype=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff}) 
4238   
4239 -    def __delfield_pbslotandtype(self): del self.__field_pbslotandtype 
4240   
4241      pbslotandtype=property(__getfield_pbslotandtype, __setfield_pbslotandtype, __delfield_pbslotandtype, None) 
4242   
4243 -    def iscontainer(self): 
4244          return True 
4245   
4246 -    def containerelements(self): 
4247          yield ('pbslotandtype', self.__field_pbslotandtype, None) 
4248   
4249   
4250   
4251   
4252 -class _gen_p_sanyo3200_238(BaseProtogenClass): 
4253      'Anonymous inner class' 
4254      __fields=['pbslotandtype'] 
4255   
4256 -    def __init__(self, *args, **kwargs): 
4257          dict={} 
4258          # What was supplied to this function 
4259          dict.update(kwargs) 
4260          # Parent constructor 
4261          super(_gen_p_sanyo3200_238,self).__init__(**dict) 
4262          if self.__class__ is _gen_p_sanyo3200_238: 
4263              self._update(args,dict) 
4264   
4265   
4266 -    def getfields(self): 
4267          return self.__fields 
4268   
4269   
4270 -    def _update(self, args, kwargs): 
4271          super(_gen_p_sanyo3200_238,self)._update(args,kwargs) 
4272          keys=kwargs.keys() 
4273          for key in keys: 
4274              if key in self.__fields: 
4275                  setattr(self, key, kwargs[key]) 
4276                  del kwargs[key] 
4277          # Were any unrecognized kwargs passed in? 
4278          if __debug__: 
4279              self._complainaboutunusedargs(_gen_p_sanyo3200_238,kwargs) 
4280          if len(args): 
4281              dict2={'sizeinbytes': 2, 'default': 0xffff} 
4282              dict2.update(kwargs) 
4283              kwargs=dict2 
4284              self.__field_pbslotandtype=UINT(*args,**dict2) 
4285          # Make all P fields that haven't already been constructed 
4286   
4287   
4288 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
4289          'Writes this packet to the supplied buffer' 
4290          self._bufferstartoffset=buf.getcurrentoffset() 
4291          self.__field_pbslotandtype.writetobuffer(buf) 
4292          self._bufferendoffset=buf.getcurrentoffset() 
4293          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
4294   
4295   
4296 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
4297          'Reads this packet from the supplied buffer' 
4298          self._bufferstartoffset=buf.getcurrentoffset() 
4299          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
4300          self.__field_pbslotandtype=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
4301          self.__field_pbslotandtype.readfrombuffer(buf) 
4302          self._bufferendoffset=buf.getcurrentoffset() 
4303   
4304   
4305 -    def __getfield_pbslotandtype(self): 
4306          return self.__field_pbslotandtype.getvalue() 
4307   
4308 -    def __setfield_pbslotandtype(self, value): 
4309          if isinstance(value,UINT): 
4310              self.__field_pbslotandtype=value 
4311          else: 
4312              self.__field_pbslotandtype=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff}) 
4313   
4314 -    def __delfield_pbslotandtype(self): del self.__field_pbslotandtype 
4315   
4316      pbslotandtype=property(__getfield_pbslotandtype, __setfield_pbslotandtype, __delfield_pbslotandtype, None) 
4317   
4318 -    def iscontainer(self): 
4319          return True 
4320   
4321 -    def containerelements(self): 
4322          yield ('pbslotandtype', self.__field_pbslotandtype, None) 
4323   
4324   
4325   
4326   
4327 -class _gen_p_sanyo3200_240(BaseProtogenClass): 
4328      'Anonymous inner class' 
4329      __fields=['pbslot'] 
4330   
4331 -    def __init__(self, *args, **kwargs): 
4332          dict={} 
4333          # What was supplied to this function 
4334          dict.update(kwargs) 
4335          # Parent constructor 
4336          super(_gen_p_sanyo3200_240,self).__init__(**dict) 
4337          if self.__class__ is _gen_p_sanyo3200_240: 
4338              self._update(args,dict) 
4339   
4340   
4341 -    def getfields(self): 
4342          return self.__fields 
4343   
4344   
4345 -    def _update(self, args, kwargs): 
4346          super(_gen_p_sanyo3200_240,self)._update(args,kwargs) 
4347          keys=kwargs.keys() 
4348          for key in keys: 
4349              if key in self.__fields: 
4350                  setattr(self, key, kwargs[key]) 
4351                  del kwargs[key] 
4352          # Were any unrecognized kwargs passed in? 
4353          if __debug__: 
4354              self._complainaboutunusedargs(_gen_p_sanyo3200_240,kwargs) 
4355          if len(args): 
4356              dict2={'sizeinbytes': 2, 'default': 0xffff} 
4357              dict2.update(kwargs) 
4358              kwargs=dict2 
4359              self.__field_pbslot=UINT(*args,**dict2) 
4360          # Make all P fields that haven't already been constructed 
4361   
4362   
4363 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
4364          'Writes this packet to the supplied buffer' 
4365          self._bufferstartoffset=buf.getcurrentoffset() 
4366          self.__field_pbslot.writetobuffer(buf) 
4367          self._bufferendoffset=buf.getcurrentoffset() 
4368          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
4369   
4370   
4371 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
4372          'Reads this packet from the supplied buffer' 
4373          self._bufferstartoffset=buf.getcurrentoffset() 
4374          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
4375          self.__field_pbslot=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
4376          self.__field_pbslot.readfrombuffer(buf) 
4377          self._bufferendoffset=buf.getcurrentoffset() 
4378   
4379   
4380 -    def __getfield_pbslot(self): 
4381          return self.__field_pbslot.getvalue() 
4382   
4383 -    def __setfield_pbslot(self, value): 
4384          if isinstance(value,UINT): 
4385              self.__field_pbslot=value 
4386          else: 
4387              self.__field_pbslot=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff}) 
4388   
4389 -    def __delfield_pbslot(self): del self.__field_pbslot 
4390   
4391      pbslot=property(__getfield_pbslot, __setfield_pbslot, __delfield_pbslot, None) 
4392   
4393 -    def iscontainer(self): 
4394          return True 
4395   
4396 -    def containerelements(self): 
4397          yield ('pbslot', self.__field_pbslot, None) 
4398   
4399   
4400   
4401   
4402 -class _gen_p_sanyo3200_243(BaseProtogenClass): 
4403      'Anonymous inner class' 
4404      __fields=['pbslot'] 
4405   
4406 -    def __init__(self, *args, **kwargs): 
4407          dict={} 
4408          # What was supplied to this function 
4409          dict.update(kwargs) 
4410          # Parent constructor 
4411          super(_gen_p_sanyo3200_243,self).__init__(**dict) 
4412          if self.__class__ is _gen_p_sanyo3200_243: 
4413              self._update(args,dict) 
4414   
4415   
4416 -    def getfields(self): 
4417          return self.__fields 
4418   
4419   
4420 -    def _update(self, args, kwargs): 
4421          super(_gen_p_sanyo3200_243,self)._update(args,kwargs) 
4422          keys=kwargs.keys() 
4423          for key in keys: 
4424              if key in self.__fields: 
4425                  setattr(self, key, kwargs[key]) 
4426                  del kwargs[key] 
4427          # Were any unrecognized kwargs passed in? 
4428          if __debug__: 
4429              self._complainaboutunusedargs(_gen_p_sanyo3200_243,kwargs) 
4430          if len(args): 
4431              dict2={'sizeinbytes': 2, 'default': 0xffff} 
4432              dict2.update(kwargs) 
4433              kwargs=dict2 
4434              self.__field_pbslot=UINT(*args,**dict2) 
4435          # Make all P fields that haven't already been constructed 
4436   
4437   
4438 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
4439          'Writes this packet to the supplied buffer' 
4440          self._bufferstartoffset=buf.getcurrentoffset() 
4441          self.__field_pbslot.writetobuffer(buf) 
4442          self._bufferendoffset=buf.getcurrentoffset() 
4443          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
4444   
4445   
4446 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
4447          'Reads this packet from the supplied buffer' 
4448          self._bufferstartoffset=buf.getcurrentoffset() 
4449          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
4450          self.__field_pbslot=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
4451          self.__field_pbslot.readfrombuffer(buf) 
4452          self._bufferendoffset=buf.getcurrentoffset() 
4453   
4454   
4455 -    def __getfield_pbslot(self): 
4456          return self.__field_pbslot.getvalue() 
4457   
4458 -    def __setfield_pbslot(self, value): 
4459          if isinstance(value,UINT): 
4460              self.__field_pbslot=value 
4461          else: 
4462              self.__field_pbslot=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff}) 
4463   
4464 -    def __delfield_pbslot(self): del self.__field_pbslot 
4465   
4466      pbslot=property(__getfield_pbslot, __setfield_pbslot, __delfield_pbslot, None) 
4467   
4468 -    def iscontainer(self): 
4469          return True 
4470   
4471 -    def containerelements(self): 
4472          yield ('pbslot', self.__field_pbslot, None) 
4473   
4474   
4475   
4476   
4477 -class wallpaperbuffer(BaseProtogenClass): 
4478      "Addition buffer of wallpaper assignment info" 
4479      __fields=['numpbslots', 'startcommand', 'bufsize', 'comment', 'wallpapers', 'pad'] 
4480   
4481 -    def __init__(self, *args, **kwargs): 
4482          dict={} 
4483          # What was supplied to this function 
4484          dict.update(kwargs) 
4485          # Parent constructor 
4486          super(wallpaperbuffer,self).__init__(**dict) 
4487          if self.__class__ is wallpaperbuffer: 
4488              self._update(args,dict) 
4489   
4490   
4491 -    def getfields(self): 
4492          return self.__fields 
4493   
4494   
4495 -    def _update(self, args, kwargs): 
4496          super(wallpaperbuffer,self)._update(args,kwargs) 
4497          keys=kwargs.keys() 
4498          for key in keys: 
4499              if key in self.__fields: 
4500                  setattr(self, key, kwargs[key]) 
4501                  del kwargs[key] 
4502          # Were any unrecognized kwargs passed in? 
4503          if __debug__: 
4504              self._complainaboutunusedargs(wallpaperbuffer,kwargs) 
4505          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
4506          # Make all P fields that haven't already been constructed 
4507          try: self.__field_numpbslots 
4508          except: 
4509              self.__field_numpbslots=UINT(**{'constant': _NUMPBSLOTS}) 
4510          try: self.__field_startcommand 
4511          except: 
4512              self.__field_startcommand=UINT(**{'constant': 0x69}) 
4513          try: self.__field_bufsize 
4514          except: 
4515              self.__field_bufsize=UINT(**{'constant': 2048}) 
4516          try: self.__field_comment 
4517          except: 
4518              self.__field_comment=USTRING(**{'default': "wallpaper assignment info"}) 
4519   
4520   
4521 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
4522          'Writes this packet to the supplied buffer' 
4523          self._bufferstartoffset=buf.getcurrentoffset() 
4524          try: self.__field_wallpapers 
4525          except: 
4526              self.__field_wallpapers=LIST(**{'length': _NUMPBSLOTS, 'elementclass': wallpaperinfo}) 
4527          self.__field_wallpapers.writetobuffer(buf) 
4528          try: self.__field_pad 
4529          except: 
4530              self.__field_pad=UNKNOWN(**{'sizeinbytes': 548}) 
4531          self.__field_pad.writetobuffer(buf) 
4532          self._bufferendoffset=buf.getcurrentoffset() 
4533          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
4534   
4535   
4536 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
4537          'Reads this packet from the supplied buffer' 
4538          self._bufferstartoffset=buf.getcurrentoffset() 
4539          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
4540          self.__field_wallpapers=LIST(**{'length': _NUMPBSLOTS, 'elementclass': wallpaperinfo}) 
4541          self.__field_wallpapers.readfrombuffer(buf) 
4542          self.__field_pad=UNKNOWN(**{'sizeinbytes': 548}) 
4543          self.__field_pad.readfrombuffer(buf) 
4544          self._bufferendoffset=buf.getcurrentoffset() 
4545   
4546   
4547 -    def __getfield_numpbslots(self): 
4548          return self.__field_numpbslots.getvalue() 
4549   
4550 -    def __setfield_numpbslots(self, value): 
4551          if isinstance(value,UINT): 
4552              self.__field_numpbslots=value 
4553          else: 
4554              self.__field_numpbslots=UINT(value,**{'constant': _NUMPBSLOTS}) 
4555   
4556 -    def __delfield_numpbslots(self): del self.__field_numpbslots 
4557   
4558      numpbslots=property(__getfield_numpbslots, __setfield_numpbslots, __delfield_numpbslots, "Number of phone book slots") 
4559   
4560 -    def __getfield_startcommand(self): 
4561          return self.__field_startcommand.getvalue() 
4562   
4563 -    def __setfield_startcommand(self, value): 
4564          if isinstance(value,UINT): 
4565              self.__field_startcommand=value 
4566          else: 
4567              self.__field_startcommand=UINT(value,**{'constant': 0x69}) 
4568   
4569 -    def __delfield_startcommand(self): del self.__field_startcommand 
4570   
4571      startcommand=property(__getfield_startcommand, __setfield_startcommand, __delfield_startcommand, "Starting command for R/W buf parts") 
4572   
4573 -    def __getfield_bufsize(self): 
4574          return self.__field_bufsize.getvalue() 
4575   
4576 -    def __setfield_bufsize(self, value): 
4577          if isinstance(value,UINT): 
4578              self.__field_bufsize=value 
4579          else: 
4580              self.__field_bufsize=UINT(value,**{'constant': 2048}) 
4581   
4582 -    def __delfield_bufsize(self): del self.__field_bufsize 
4583   
4584      bufsize=property(__getfield_bufsize, __setfield_bufsize, __delfield_bufsize, None) 
4585   
4586 -    def __getfield_comment(self): 
4587          try: self.__field_comment 
4588          except: 
4589              self.__field_comment=USTRING(**{'default': "wallpaper assignment info"}) 
4590          return self.__field_comment.getvalue() 
4591   
4592 -    def __setfield_comment(self, value): 
4593          if isinstance(value,USTRING): 
4594              self.__field_comment=value 
4595          else: 
4596              self.__field_comment=USTRING(value,**{'default': "wallpaper assignment info"}) 
4597   
4598 -    def __delfield_comment(self): del self.__field_comment 
4599   
4600      comment=property(__getfield_comment, __setfield_comment, __delfield_comment, None) 
4601   
4602 -    def __getfield_wallpapers(self): 
4603          try: self.__field_wallpapers 
4604          except: 
4605              self.__field_wallpapers=LIST(**{'length': _NUMPBSLOTS, 'elementclass': wallpaperinfo}) 
4606          return self.__field_wallpapers.getvalue() 
4607   
4608 -    def __setfield_wallpapers(self, value): 
4609          if isinstance(value,LIST): 
4610              self.__field_wallpapers=value 
4611          else: 
4612              self.__field_wallpapers=LIST(value,**{'length': _NUMPBSLOTS, 'elementclass': wallpaperinfo}) 
4613   
4614 -    def __delfield_wallpapers(self): del self.__field_wallpapers 
4615   
4616      wallpapers=property(__getfield_wallpapers, __setfield_wallpapers, __delfield_wallpapers, None) 
4617   
4618 -    def __getfield_pad(self): 
4619          try: self.__field_pad 
4620          except: 
4621              self.__field_pad=UNKNOWN(**{'sizeinbytes': 548}) 
4622          return self.__field_pad.getvalue() 
4623   
4624 -    def __setfield_pad(self, value): 
4625          if isinstance(value,UNKNOWN): 
4626              self.__field_pad=value 
4627          else: 
4628              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 548}) 
4629   
4630 -    def __delfield_pad(self): del self.__field_pad 
4631   
4632      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
4633   
4634 -    def iscontainer(self): 
4635          return True 
4636   
4637 -    def containerelements(self): 
4638          yield ('numpbslots', self.__field_numpbslots, "Number of phone book slots") 
4639          yield ('startcommand', self.__field_startcommand, "Starting command for R/W buf parts") 
4640          yield ('bufsize', self.__field_bufsize, None) 
4641          yield ('comment', self.__field_comment, None) 
4642          yield ('wallpapers', self.__field_wallpapers, None) 
4643          yield ('pad', self.__field_pad, None) 
4644   
4645   
4646   
4647   
4648 -class messagerequest(BaseProtogenClass): 
4649      __fields=['header', 'slot', 'pad'] 
4650   
4651 -    def __init__(self, *args, **kwargs): 
4652          dict={} 
4653          # What was supplied to this function 
4654          dict.update(kwargs) 
4655          # Parent constructor 
4656          super(messagerequest,self).__init__(**dict) 
4657          if self.__class__ is messagerequest: 
4658              self._update(args,dict) 
4659   
4660   
4661 -    def getfields(self): 
4662          return self.__fields 
4663   
4664   
4665 -    def _update(self, args, kwargs): 
4666          super(messagerequest,self)._update(args,kwargs) 
4667          keys=kwargs.keys() 
4668          for key in keys: 
4669              if key in self.__fields: 
4670                  setattr(self, key, kwargs[key]) 
4671                  del kwargs[key] 
4672          # Were any unrecognized kwargs passed in? 
4673          if __debug__: 
4674              self._complainaboutunusedargs(messagerequest,kwargs) 
4675          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
4676          # Make all P fields that haven't already been constructed 
4677   
4678   
4679 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
4680          'Writes this packet to the supplied buffer' 
4681          self._bufferstartoffset=buf.getcurrentoffset() 
4682          try: self.__field_header 
4683          except: 
4684              self.__field_header=sanyoheader(**{'packettype': 0x0c,                   'command': 0xe1}) 
4685          self.__field_header.writetobuffer(buf) 
4686          self.__field_slot.writetobuffer(buf) 
4687          try: self.__field_pad 
4688          except: 
4689              self.__field_pad=UNKNOWN(**{'sizeinbytes': 501}) 
4690          self.__field_pad.writetobuffer(buf) 
4691          self._bufferendoffset=buf.getcurrentoffset() 
4692          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
4693   
4694   
4695 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
4696          'Reads this packet from the supplied buffer' 
4697          self._bufferstartoffset=buf.getcurrentoffset() 
4698          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
4699          self.__field_header=sanyoheader(**{'packettype': 0x0c,                   'command': 0xe1}) 
4700          self.__field_header.readfrombuffer(buf) 
4701          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
4702          self.__field_slot.readfrombuffer(buf) 
4703          self.__field_pad=UNKNOWN(**{'sizeinbytes': 501}) 
4704          self.__field_pad.readfrombuffer(buf) 
4705          self._bufferendoffset=buf.getcurrentoffset() 
4706   
4707   
4708 -    def __getfield_header(self): 
4709          try: self.__field_header 
4710          except: 
4711              self.__field_header=sanyoheader(**{'packettype': 0x0c,                   'command': 0xe1}) 
4712          return self.__field_header.getvalue() 
4713   
4714 -    def __setfield_header(self, value): 
4715          if isinstance(value,sanyoheader): 
4716              self.__field_header=value 
4717          else: 
4718              self.__field_header=sanyoheader(value,**{'packettype': 0x0c,                   'command': 0xe1}) 
4719   
4720 -    def __delfield_header(self): del self.__field_header 
4721   
4722      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
4723   
4724 -    def __getfield_slot(self): 
4725          return self.__field_slot.getvalue() 
4726   
4727 -    def __setfield_slot(self, value): 
4728          if isinstance(value,UINT): 
4729              self.__field_slot=value 
4730          else: 
4731              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
4732   
4733 -    def __delfield_slot(self): del self.__field_slot 
4734   
4735      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
4736   
4737 -    def __getfield_pad(self): 
4738          try: self.__field_pad 
4739          except: 
4740              self.__field_pad=UNKNOWN(**{'sizeinbytes': 501}) 
4741          return self.__field_pad.getvalue() 
4742   
4743 -    def __setfield_pad(self, value): 
4744          if isinstance(value,UNKNOWN): 
4745              self.__field_pad=value 
4746          else: 
4747              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 501}) 
4748   
4749 -    def __delfield_pad(self): del self.__field_pad 
4750   
4751      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
4752   
4753 -    def iscontainer(self): 
4754          return True 
4755   
4756 -    def containerelements(self): 
4757          yield ('header', self.__field_header, None) 
4758          yield ('slot', self.__field_slot, None) 
4759          yield ('pad', self.__field_pad, None) 
4760   
4761   
4762   
4763   
4764 -class messagesentrequest(BaseProtogenClass): 
4765      __fields=['header', 'slot', 'pad'] 
4766   
4767 -    def __init__(self, *args, **kwargs): 
4768          dict={} 
4769          # What was supplied to this function 
4770          dict.update(kwargs) 
4771          # Parent constructor 
4772          super(messagesentrequest,self).__init__(**dict) 
4773          if self.__class__ is messagesentrequest: 
4774              self._update(args,dict) 
4775   
4776   
4777 -    def getfields(self): 
4778          return self.__fields 
4779   
4780   
4781 -    def _update(self, args, kwargs): 
4782          super(messagesentrequest,self)._update(args,kwargs) 
4783          keys=kwargs.keys() 
4784          for key in keys: 
4785              if key in self.__fields: 
4786                  setattr(self, key, kwargs[key]) 
4787                  del kwargs[key] 
4788          # Were any unrecognized kwargs passed in? 
4789          if __debug__: 
4790              self._complainaboutunusedargs(messagesentrequest,kwargs) 
4791          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
4792          # Make all P fields that haven't already been constructed 
4793   
4794   
4795 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
4796          'Writes this packet to the supplied buffer' 
4797          self._bufferstartoffset=buf.getcurrentoffset() 
4798          try: self.__field_header 
4799          except: 
4800              self.__field_header=sanyoheader(**{'packettype': 0x0d,                   'command': 0x55}) 
4801          self.__field_header.writetobuffer(buf) 
4802          self.__field_slot.writetobuffer(buf) 
4803          try: self.__field_pad 
4804          except: 
4805              self.__field_pad=UNKNOWN(**{'sizeinbytes': 501}) 
4806          self.__field_pad.writetobuffer(buf) 
4807          self._bufferendoffset=buf.getcurrentoffset() 
4808          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
4809   
4810   
4811 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
4812          'Reads this packet from the supplied buffer' 
4813          self._bufferstartoffset=buf.getcurrentoffset() 
4814          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
4815          self.__field_header=sanyoheader(**{'packettype': 0x0d,                   'command': 0x55}) 
4816          self.__field_header.readfrombuffer(buf) 
4817          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
4818          self.__field_slot.readfrombuffer(buf) 
4819          self.__field_pad=UNKNOWN(**{'sizeinbytes': 501}) 
4820          self.__field_pad.readfrombuffer(buf) 
4821          self._bufferendoffset=buf.getcurrentoffset() 
4822   
4823   
4824 -    def __getfield_header(self): 
4825          try: self.__field_header 
4826          except: 
4827              self.__field_header=sanyoheader(**{'packettype': 0x0d,                   'command': 0x55}) 
4828          return self.__field_header.getvalue() 
4829   
4830 -    def __setfield_header(self, value): 
4831          if isinstance(value,sanyoheader): 
4832              self.__field_header=value 
4833          else: 
4834              self.__field_header=sanyoheader(value,**{'packettype': 0x0d,                   'command': 0x55}) 
4835   
4836 -    def __delfield_header(self): del self.__field_header 
4837   
4838      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
4839   
4840 -    def __getfield_slot(self): 
4841          return self.__field_slot.getvalue() 
4842   
4843 -    def __setfield_slot(self, value): 
4844          if isinstance(value,UINT): 
4845              self.__field_slot=value 
4846          else: 
4847              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
4848   
4849 -    def __delfield_slot(self): del self.__field_slot 
4850   
4851      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
4852   
4853 -    def __getfield_pad(self): 
4854          try: self.__field_pad 
4855          except: 
4856              self.__field_pad=UNKNOWN(**{'sizeinbytes': 501}) 
4857          return self.__field_pad.getvalue() 
4858   
4859 -    def __setfield_pad(self, value): 
4860          if isinstance(value,UNKNOWN): 
4861              self.__field_pad=value 
4862          else: 
4863              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 501}) 
4864   
4865 -    def __delfield_pad(self): del self.__field_pad 
4866   
4867      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
4868   
4869 -    def iscontainer(self): 
4870          return True 
4871   
4872 -    def containerelements(self): 
4873          yield ('header', self.__field_header, None) 
4874          yield ('slot', self.__field_slot, None) 
4875          yield ('pad', self.__field_pad, None) 
4876   
4877   
4878   
4879   
4880 -class messageentry(BaseProtogenClass): 
4881      __fields=['slot', 'read', 'counter', 'pad1', 'dunno1', 'dunno2', 'dunno3', 'pad2', 'dunno4', 'dunno5', 'pad3', 'message_len', 'message', 'pad4', 'year', 'month', 'day', 'hour', 'minute', 'second', 'callback_len', 'callback', 'phonenum_len', 'phonenum', 'dunno6', 'priority', 'pad6', 'dunno7', 'dunno8'] 
4882   
4883 -    def __init__(self, *args, **kwargs): 
4884          dict={} 
4885          # What was supplied to this function 
4886          dict.update(kwargs) 
4887          # Parent constructor 
4888          super(messageentry,self).__init__(**dict) 
4889          if self.__class__ is messageentry: 
4890              self._update(args,dict) 
4891   
4892   
4893 -    def getfields(self): 
4894          return self.__fields 
4895   
4896   
4897 -    def _update(self, args, kwargs): 
4898          super(messageentry,self)._update(args,kwargs) 
4899          keys=kwargs.keys() 
4900          for key in keys: 
4901              if key in self.__fields: 
4902                  setattr(self, key, kwargs[key]) 
4903                  del kwargs[key] 
4904          # Were any unrecognized kwargs passed in? 
4905          if __debug__: 
4906              self._complainaboutunusedargs(messageentry,kwargs) 
4907          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
4908          # Make all P fields that haven't already been constructed 
4909   
4910   
4911 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
4912          'Writes this packet to the supplied buffer' 
4913          self._bufferstartoffset=buf.getcurrentoffset() 
4914          self.__field_slot.writetobuffer(buf) 
4915          self.__field_read.writetobuffer(buf) 
4916          self.__field_counter.writetobuffer(buf) 
4917          self.__field_pad1.writetobuffer(buf) 
4918          self.__field_dunno1.writetobuffer(buf) 
4919          self.__field_dunno2.writetobuffer(buf) 
4920          self.__field_dunno3.writetobuffer(buf) 
4921          self.__field_pad2.writetobuffer(buf) 
4922          self.__field_dunno4.writetobuffer(buf) 
4923          self.__field_dunno5.writetobuffer(buf) 
4924          self.__field_pad3.writetobuffer(buf) 
4925          self.__field_message_len.writetobuffer(buf) 
4926          self.__field_message.writetobuffer(buf) 
4927          self.__field_pad4.writetobuffer(buf) 
4928          self.__field_year.writetobuffer(buf) 
4929          self.__field_month.writetobuffer(buf) 
4930          self.__field_day.writetobuffer(buf) 
4931          self.__field_hour.writetobuffer(buf) 
4932          self.__field_minute.writetobuffer(buf) 
4933          self.__field_second.writetobuffer(buf) 
4934          self.__field_callback_len.writetobuffer(buf) 
4935          self.__field_callback.writetobuffer(buf) 
4936          self.__field_phonenum_len.writetobuffer(buf) 
4937          self.__field_phonenum.writetobuffer(buf) 
4938          self.__field_dunno6.writetobuffer(buf) 
4939          self.__field_priority.writetobuffer(buf) 
4940          self.__field_pad6.writetobuffer(buf) 
4941          self.__field_dunno7.writetobuffer(buf) 
4942          self.__field_dunno8.writetobuffer(buf) 
4943          self._bufferendoffset=buf.getcurrentoffset() 
4944          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
4945   
4946   
4947 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
4948          'Reads this packet from the supplied buffer' 
4949          self._bufferstartoffset=buf.getcurrentoffset() 
4950          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
4951          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
4952          self.__field_slot.readfrombuffer(buf) 
4953          self.__field_read=UINT(**{'sizeinbytes': 1}) 
4954          self.__field_read.readfrombuffer(buf) 
4955          self.__field_counter=UINT(**{'sizeinbytes': 1}) 
4956          self.__field_counter.readfrombuffer(buf) 
4957          self.__field_pad1=UNKNOWN(**{'sizeinbytes': 3}) 
4958          self.__field_pad1.readfrombuffer(buf) 
4959          self.__field_dunno1=UINT(**{'sizeinbytes': 1}) 
4960          self.__field_dunno1.readfrombuffer(buf) 
4961          self.__field_dunno2=UINT(**{'sizeinbytes': 1}) 
4962          self.__field_dunno2.readfrombuffer(buf) 
4963          self.__field_dunno3=UINT(**{'sizeinbytes': 1}) 
4964          self.__field_dunno3.readfrombuffer(buf) 
4965          self.__field_pad2=UNKNOWN(**{'sizeinbytes': 1}) 
4966          self.__field_pad2.readfrombuffer(buf) 
4967          self.__field_dunno4=UINT(**{'sizeinbytes': 1}) 
4968          self.__field_dunno4.readfrombuffer(buf) 
4969          self.__field_dunno5=UINT(**{'sizeinbytes': 1}) 
4970          self.__field_dunno5.readfrombuffer(buf) 
4971          self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1}) 
4972          self.__field_pad3.readfrombuffer(buf) 
4973          self.__field_message_len=UINT(**{'sizeinbytes': 1}) 
4974          self.__field_message_len.readfrombuffer(buf) 
4975          self.__field_message=USTRING(**{'sizeinbytes': 255}) 
4976          self.__field_message.readfrombuffer(buf) 
4977          self.__field_pad4=UNKNOWN(**{'sizeinbytes': 1}) 
4978          self.__field_pad4.readfrombuffer(buf) 
4979          self.__field_year=UINT(**{'sizeinbytes': 1}) 
4980          self.__field_year.readfrombuffer(buf) 
4981          self.__field_month=UINT(**{'sizeinbytes': 1}) 
4982          self.__field_month.readfrombuffer(buf) 
4983          self.__field_day=UINT(**{'sizeinbytes': 1}) 
4984          self.__field_day.readfrombuffer(buf) 
4985          self.__field_hour=UINT(**{'sizeinbytes': 1}) 
4986          self.__field_hour.readfrombuffer(buf) 
4987          self.__field_minute=UINT(**{'sizeinbytes': 1}) 
4988          self.__field_minute.readfrombuffer(buf) 
4989          self.__field_second=UINT(**{'sizeinbytes': 1}) 
4990          self.__field_second.readfrombuffer(buf) 
4991          self.__field_callback_len=UINT(**{'sizeinbytes': 1}) 
4992          self.__field_callback_len.readfrombuffer(buf) 
4993          self.__field_callback=USTRING(**{'sizeinbytes': 34}) 
4994          self.__field_callback.readfrombuffer(buf) 
4995          self.__field_phonenum_len=UINT(**{'sizeinbytes': 1}) 
4996          self.__field_phonenum_len.readfrombuffer(buf) 
4997          self.__field_phonenum=USTRING(**{'sizeinbytes': 37}) 
4998          self.__field_phonenum.readfrombuffer(buf) 
4999          self.__field_dunno6=UINT(**{'sizeinbytes': 1}) 
5000          self.__field_dunno6.readfrombuffer(buf) 
5001          self.__field_priority=UINT(**{'sizeinbytes': 1}) 
5002          self.__field_priority.readfrombuffer(buf) 
5003          self.__field_pad6=UNKNOWN(**{'sizeinbytes': 3}) 
5004          self.__field_pad6.readfrombuffer(buf) 
5005          self.__field_dunno7=UINT(**{'sizeinbytes': 1}) 
5006          self.__field_dunno7.readfrombuffer(buf) 
5007          self.__field_dunno8=UINT(**{'sizeinbytes': 1}) 
5008          self.__field_dunno8.readfrombuffer(buf) 
5009          self._bufferendoffset=buf.getcurrentoffset() 
5010   
5011   
5012 -    def __getfield_slot(self): 
5013          return self.__field_slot.getvalue() 
5014   
5015 -    def __setfield_slot(self, value): 
5016          if isinstance(value,UINT): 
5017              self.__field_slot=value 
5018          else: 
5019              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
5020   
5021 -    def __delfield_slot(self): del self.__field_slot 
5022   
5023      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
5024   
5025 -    def __getfield_read(self): 
5026          return self.__field_read.getvalue() 
5027   
5028 -    def __setfield_read(self, value): 
5029          if isinstance(value,UINT): 
5030              self.__field_read=value 
5031          else: 
5032              self.__field_read=UINT(value,**{'sizeinbytes': 1}) 
5033   
5034 -    def __delfield_read(self): del self.__field_read 
5035   
5036      read=property(__getfield_read, __setfield_read, __delfield_read, None) 
5037   
5038 -    def __getfield_counter(self): 
5039          return self.__field_counter.getvalue() 
5040   
5041 -    def __setfield_counter(self, value): 
5042          if isinstance(value,UINT): 
5043              self.__field_counter=value 
5044          else: 
5045              self.__field_counter=UINT(value,**{'sizeinbytes': 1}) 
5046   
5047 -    def __delfield_counter(self): del self.__field_counter 
5048   
5049      counter=property(__getfield_counter, __setfield_counter, __delfield_counter, None) 
5050   
5051 -    def __getfield_pad1(self): 
5052          return self.__field_pad1.getvalue() 
5053   
5054 -    def __setfield_pad1(self, value): 
5055          if isinstance(value,UNKNOWN): 
5056              self.__field_pad1=value 
5057          else: 
5058              self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 3}) 
5059   
5060 -    def __delfield_pad1(self): del self.__field_pad1 
5061   
5062      pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None) 
5063   
5064 -    def __getfield_dunno1(self): 
5065          return self.__field_dunno1.getvalue() 
5066   
5067 -    def __setfield_dunno1(self, value): 
5068          if isinstance(value,UINT): 
5069              self.__field_dunno1=value 
5070          else: 
5071              self.__field_dunno1=UINT(value,**{'sizeinbytes': 1}) 
5072   
5073 -    def __delfield_dunno1(self): del self.__field_dunno1 
5074   
5075      dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None) 
5076   
5077 -    def __getfield_dunno2(self): 
5078          return self.__field_dunno2.getvalue() 
5079   
5080 -    def __setfield_dunno2(self, value): 
5081          if isinstance(value,UINT): 
5082              self.__field_dunno2=value 
5083          else: 
5084              self.__field_dunno2=UINT(value,**{'sizeinbytes': 1}) 
5085   
5086 -    def __delfield_dunno2(self): del self.__field_dunno2 
5087   
5088      dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None) 
5089   
5090 -    def __getfield_dunno3(self): 
5091          return self.__field_dunno3.getvalue() 
5092   
5093 -    def __setfield_dunno3(self, value): 
5094          if isinstance(value,UINT): 
5095              self.__field_dunno3=value 
5096          else: 
5097              self.__field_dunno3=UINT(value,**{'sizeinbytes': 1}) 
5098   
5099 -    def __delfield_dunno3(self): del self.__field_dunno3 
5100   
5101      dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None) 
5102   
5103 -    def __getfield_pad2(self): 
5104          return self.__field_pad2.getvalue() 
5105   
5106 -    def __setfield_pad2(self, value): 
5107          if isinstance(value,UNKNOWN): 
5108              self.__field_pad2=value 
5109          else: 
5110              self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 1}) 
5111   
5112 -    def __delfield_pad2(self): del self.__field_pad2 
5113   
5114      pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None) 
5115   
5116 -    def __getfield_dunno4(self): 
5117          return self.__field_dunno4.getvalue() 
5118   
5119 -    def __setfield_dunno4(self, value): 
5120          if isinstance(value,UINT): 
5121              self.__field_dunno4=value 
5122          else: 
5123              self.__field_dunno4=UINT(value,**{'sizeinbytes': 1}) 
5124   
5125 -    def __delfield_dunno4(self): del self.__field_dunno4 
5126   
5127      dunno4=property(__getfield_dunno4, __setfield_dunno4, __delfield_dunno4, None) 
5128   
5129 -    def __getfield_dunno5(self): 
5130          return self.__field_dunno5.getvalue() 
5131   
5132 -    def __setfield_dunno5(self, value): 
5133          if isinstance(value,UINT): 
5134              self.__field_dunno5=value 
5135          else: 
5136              self.__field_dunno5=UINT(value,**{'sizeinbytes': 1}) 
5137   
5138 -    def __delfield_dunno5(self): del self.__field_dunno5 
5139   
5140      dunno5=property(__getfield_dunno5, __setfield_dunno5, __delfield_dunno5, None) 
5141   
5142 -    def __getfield_pad3(self): 
5143          return self.__field_pad3.getvalue() 
5144   
5145 -    def __setfield_pad3(self, value): 
5146          if isinstance(value,UNKNOWN): 
5147              self.__field_pad3=value 
5148          else: 
5149              self.__field_pad3=UNKNOWN(value,**{'sizeinbytes': 1}) 
5150   
5151 -    def __delfield_pad3(self): del self.__field_pad3 
5152   
5153      pad3=property(__getfield_pad3, __setfield_pad3, __delfield_pad3, None) 
5154   
5155 -    def __getfield_message_len(self): 
5156          return self.__field_message_len.getvalue() 
5157   
5158 -    def __setfield_message_len(self, value): 
5159          if isinstance(value,UINT): 
5160              self.__field_message_len=value 
5161          else: 
5162              self.__field_message_len=UINT(value,**{'sizeinbytes': 1}) 
5163   
5164 -    def __delfield_message_len(self): del self.__field_message_len 
5165   
5166      message_len=property(__getfield_message_len, __setfield_message_len, __delfield_message_len, None) 
5167   
5168 -    def __getfield_message(self): 
5169          return self.__field_message.getvalue() 
5170   
5171 -    def __setfield_message(self, value): 
5172          if isinstance(value,USTRING): 
5173              self.__field_message=value 
5174          else: 
5175              self.__field_message=USTRING(value,**{'sizeinbytes': 255}) 
5176   
5177 -    def __delfield_message(self): del self.__field_message 
5178   
5179      message=property(__getfield_message, __setfield_message, __delfield_message, "Text of the notification") 
5180   
5181 -    def __getfield_pad4(self): 
5182          return self.__field_pad4.getvalue() 
5183   
5184 -    def __setfield_pad4(self, value): 
5185          if isinstance(value,UNKNOWN): 
5186              self.__field_pad4=value 
5187          else: 
5188              self.__field_pad4=UNKNOWN(value,**{'sizeinbytes': 1}) 
5189   
5190 -    def __delfield_pad4(self): del self.__field_pad4 
5191   
5192      pad4=property(__getfield_pad4, __setfield_pad4, __delfield_pad4, None) 
5193   
5194 -    def __getfield_year(self): 
5195          return self.__field_year.getvalue() 
5196   
5197 -    def __setfield_year(self, value): 
5198          if isinstance(value,UINT): 
5199              self.__field_year=value 
5200          else: 
5201              self.__field_year=UINT(value,**{'sizeinbytes': 1}) 
5202   
5203 -    def __delfield_year(self): del self.__field_year 
5204   
5205      year=property(__getfield_year, __setfield_year, __delfield_year, None) 
5206   
5207 -    def __getfield_month(self): 
5208          return self.__field_month.getvalue() 
5209   
5210 -    def __setfield_month(self, value): 
5211          if isinstance(value,UINT): 
5212              self.__field_month=value 
5213          else: 
5214              self.__field_month=UINT(value,**{'sizeinbytes': 1}) 
5215   
5216 -    def __delfield_month(self): del self.__field_month 
5217   
5218      month=property(__getfield_month, __setfield_month, __delfield_month, None) 
5219   
5220 -    def __getfield_day(self): 
5221          return self.__field_day.getvalue() 
5222   
5223 -    def __setfield_day(self, value): 
5224          if isinstance(value,UINT): 
5225              self.__field_day=value 
5226          else: 
5227              self.__field_day=UINT(value,**{'sizeinbytes': 1}) 
5228   
5229 -    def __delfield_day(self): del self.__field_day 
5230   
5231      day=property(__getfield_day, __setfield_day, __delfield_day, None) 
5232   
5233 -    def __getfield_hour(self): 
5234          return self.__field_hour.getvalue() 
5235   
5236 -    def __setfield_hour(self, value): 
5237          if isinstance(value,UINT): 
5238              self.__field_hour=value 
5239          else: 
5240              self.__field_hour=UINT(value,**{'sizeinbytes': 1}) 
5241   
5242 -    def __delfield_hour(self): del self.__field_hour 
5243   
5244      hour=property(__getfield_hour, __setfield_hour, __delfield_hour, None) 
5245   
5246 -    def __getfield_minute(self): 
5247          return self.__field_minute.getvalue() 
5248   
5249 -    def __setfield_minute(self, value): 
5250          if isinstance(value,UINT): 
5251              self.__field_minute=value 
5252          else: 
5253              self.__field_minute=UINT(value,**{'sizeinbytes': 1}) 
5254   
5255 -    def __delfield_minute(self): del self.__field_minute 
5256   
5257      minute=property(__getfield_minute, __setfield_minute, __delfield_minute, None) 
5258   
5259 -    def __getfield_second(self): 
5260          return self.__field_second.getvalue() 
5261   
5262 -    def __setfield_second(self, value): 
5263          if isinstance(value,UINT): 
5264              self.__field_second=value 
5265          else: 
5266              self.__field_second=UINT(value,**{'sizeinbytes': 1}) 
5267   
5268 -    def __delfield_second(self): del self.__field_second 
5269   
5270      second=property(__getfield_second, __setfield_second, __delfield_second, None) 
5271   
5272 -    def __getfield_callback_len(self): 
5273          return self.__field_callback_len.getvalue() 
5274   
5275 -    def __setfield_callback_len(self, value): 
5276          if isinstance(value,UINT): 
5277              self.__field_callback_len=value 
5278          else: 
5279              self.__field_callback_len=UINT(value,**{'sizeinbytes': 1}) 
5280   
5281 -    def __delfield_callback_len(self): del self.__field_callback_len 
5282   
5283      callback_len=property(__getfield_callback_len, __setfield_callback_len, __delfield_callback_len, None) 
5284   
5285 -    def __getfield_callback(self): 
5286          return self.__field_callback.getvalue() 
5287   
5288 -    def __setfield_callback(self, value): 
5289          if isinstance(value,USTRING): 
5290              self.__field_callback=value 
5291          else: 
5292              self.__field_callback=USTRING(value,**{'sizeinbytes': 34}) 
5293   
5294 -    def __delfield_callback(self): del self.__field_callback 
5295   
5296      callback=property(__getfield_callback, __setfield_callback, __delfield_callback, None) 
5297   
5298 -    def __getfield_phonenum_len(self): 
5299          return self.__field_phonenum_len.getvalue() 
5300   
5301 -    def __setfield_phonenum_len(self, value): 
5302          if isinstance(value,UINT): 
5303              self.__field_phonenum_len=value 
5304          else: 
5305              self.__field_phonenum_len=UINT(value,**{'sizeinbytes': 1}) 
5306   
5307 -    def __delfield_phonenum_len(self): del self.__field_phonenum_len 
5308   
5309      phonenum_len=property(__getfield_phonenum_len, __setfield_phonenum_len, __delfield_phonenum_len, None) 
5310   
5311 -    def __getfield_phonenum(self): 
5312          return self.__field_phonenum.getvalue() 
5313   
5314 -    def __setfield_phonenum(self, value): 
5315          if isinstance(value,USTRING): 
5316              self.__field_phonenum=value 
5317          else: 
5318              self.__field_phonenum=USTRING(value,**{'sizeinbytes': 37}) 
5319   
5320 -    def __delfield_phonenum(self): del self.__field_phonenum 
5321   
5322      phonenum=property(__getfield_phonenum, __setfield_phonenum, __delfield_phonenum, None) 
5323   
5324 -    def __getfield_dunno6(self): 
5325          return self.__field_dunno6.getvalue() 
5326   
5327 -    def __setfield_dunno6(self, value): 
5328          if isinstance(value,UINT): 
5329              self.__field_dunno6=value 
5330          else: 
5331              self.__field_dunno6=UINT(value,**{'sizeinbytes': 1}) 
5332   
5333 -    def __delfield_dunno6(self): del self.__field_dunno6 
5334   
5335      dunno6=property(__getfield_dunno6, __setfield_dunno6, __delfield_dunno6, None) 
5336   
5337 -    def __getfield_priority(self): 
5338          return self.__field_priority.getvalue() 
5339   
5340 -    def __setfield_priority(self, value): 
5341          if isinstance(value,UINT): 
5342              self.__field_priority=value 
5343          else: 
5344              self.__field_priority=UINT(value,**{'sizeinbytes': 1}) 
5345   
5346 -    def __delfield_priority(self): del self.__field_priority 
5347   
5348      priority=property(__getfield_priority, __setfield_priority, __delfield_priority, None) 
5349   
5350 -    def __getfield_pad6(self): 
5351          return self.__field_pad6.getvalue() 
5352   
5353 -    def __setfield_pad6(self, value): 
5354          if isinstance(value,UNKNOWN): 
5355              self.__field_pad6=value 
5356          else: 
5357              self.__field_pad6=UNKNOWN(value,**{'sizeinbytes': 3}) 
5358   
5359 -    def __delfield_pad6(self): del self.__field_pad6 
5360   
5361      pad6=property(__getfield_pad6, __setfield_pad6, __delfield_pad6, None) 
5362   
5363 -    def __getfield_dunno7(self): 
5364          return self.__field_dunno7.getvalue() 
5365   
5366 -    def __setfield_dunno7(self, value): 
5367          if isinstance(value,UINT): 
5368              self.__field_dunno7=value 
5369          else: 
5370              self.__field_dunno7=UINT(value,**{'sizeinbytes': 1}) 
5371   
5372 -    def __delfield_dunno7(self): del self.__field_dunno7 
5373   
5374      dunno7=property(__getfield_dunno7, __setfield_dunno7, __delfield_dunno7, None) 
5375   
5376 -    def __getfield_dunno8(self): 
5377          return self.__field_dunno8.getvalue() 
5378   
5379 -    def __setfield_dunno8(self, value): 
5380          if isinstance(value,UINT): 
5381              self.__field_dunno8=value 
5382          else: 
5383              self.__field_dunno8=UINT(value,**{'sizeinbytes': 1}) 
5384   
5385 -    def __delfield_dunno8(self): del self.__field_dunno8 
5386   
5387      dunno8=property(__getfield_dunno8, __setfield_dunno8, __delfield_dunno8, None) 
5388   
5389 -    def iscontainer(self): 
5390          return True 
5391   
5392 -    def containerelements(self): 
5393          yield ('slot', self.__field_slot, None) 
5394          yield ('read', self.__field_read, None) 
5395          yield ('counter', self.__field_counter, None) 
5396          yield ('pad1', self.__field_pad1, None) 
5397          yield ('dunno1', self.__field_dunno1, None) 
5398          yield ('dunno2', self.__field_dunno2, None) 
5399          yield ('dunno3', self.__field_dunno3, None) 
5400          yield ('pad2', self.__field_pad2, None) 
5401          yield ('dunno4', self.__field_dunno4, None) 
5402          yield ('dunno5', self.__field_dunno5, None) 
5403          yield ('pad3', self.__field_pad3, None) 
5404          yield ('message_len', self.__field_message_len, None) 
5405          yield ('message', self.__field_message, "Text of the notification") 
5406          yield ('pad4', self.__field_pad4, None) 
5407          yield ('year', self.__field_year, None) 
5408          yield ('month', self.__field_month, None) 
5409          yield ('day', self.__field_day, None) 
5410          yield ('hour', self.__field_hour, None) 
5411          yield ('minute', self.__field_minute, None) 
5412          yield ('second', self.__field_second, None) 
5413          yield ('callback_len', self.__field_callback_len, None) 
5414          yield ('callback', self.__field_callback, None) 
5415          yield ('phonenum_len', self.__field_phonenum_len, None) 
5416          yield ('phonenum', self.__field_phonenum, None) 
5417          yield ('dunno6', self.__field_dunno6, None) 
5418          yield ('priority', self.__field_priority, None) 
5419          yield ('pad6', self.__field_pad6, None) 
5420          yield ('dunno7', self.__field_dunno7, None) 
5421          yield ('dunno8', self.__field_dunno8, None) 
5422   
5423   
5424   
5425   
5426 -class messageresponse(BaseProtogenClass): 
5427      __fields=['header', 'entry', 'pad'] 
5428   
5429 -    def __init__(self, *args, **kwargs): 
5430          dict={} 
5431          # What was supplied to this function 
5432          dict.update(kwargs) 
5433          # Parent constructor 
5434          super(messageresponse,self).__init__(**dict) 
5435          if self.__class__ is messageresponse: 
5436              self._update(args,dict) 
5437   
5438   
5439 -    def getfields(self): 
5440          return self.__fields 
5441   
5442   
5443 -    def _update(self, args, kwargs): 
5444          super(messageresponse,self)._update(args,kwargs) 
5445          keys=kwargs.keys() 
5446          for key in keys: 
5447              if key in self.__fields: 
5448                  setattr(self, key, kwargs[key]) 
5449                  del kwargs[key] 
5450          # Were any unrecognized kwargs passed in? 
5451          if __debug__: 
5452              self._complainaboutunusedargs(messageresponse,kwargs) 
5453          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
5454          # Make all P fields that haven't already been constructed 
5455   
5456   
5457 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
5458          'Writes this packet to the supplied buffer' 
5459          self._bufferstartoffset=buf.getcurrentoffset() 
5460          self.__field_header.writetobuffer(buf) 
5461          self.__field_entry.writetobuffer(buf) 
5462          self.__field_pad.writetobuffer(buf) 
5463          self._bufferendoffset=buf.getcurrentoffset() 
5464          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
5465   
5466   
5467 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
5468          'Reads this packet from the supplied buffer' 
5469          self._bufferstartoffset=buf.getcurrentoffset() 
5470          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
5471          self.__field_header=sanyoheader() 
5472          self.__field_header.readfrombuffer(buf) 
5473          self.__field_entry=messageentry() 
5474          self.__field_entry.readfrombuffer(buf) 
5475          self.__field_pad=UNKNOWN() 
5476          self.__field_pad.readfrombuffer(buf) 
5477          self._bufferendoffset=buf.getcurrentoffset() 
5478   
5479   
5480 -    def __getfield_header(self): 
5481          return self.__field_header.getvalue() 
5482   
5483 -    def __setfield_header(self, value): 
5484          if isinstance(value,sanyoheader): 
5485              self.__field_header=value 
5486          else: 
5487              self.__field_header=sanyoheader(value,) 
5488   
5489 -    def __delfield_header(self): del self.__field_header 
5490   
5491      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
5492   
5493 -    def __getfield_entry(self): 
5494          return self.__field_entry.getvalue() 
5495   
5496 -    def __setfield_entry(self, value): 
5497          if isinstance(value,messageentry): 
5498              self.__field_entry=value 
5499          else: 
5500              self.__field_entry=messageentry(value,) 
5501   
5502 -    def __delfield_entry(self): del self.__field_entry 
5503   
5504      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
5505   
5506 -    def __getfield_pad(self): 
5507          return self.__field_pad.getvalue() 
5508   
5509 -    def __setfield_pad(self, value): 
5510          if isinstance(value,UNKNOWN): 
5511              self.__field_pad=value 
5512          else: 
5513              self.__field_pad=UNKNOWN(value,) 
5514   
5515 -    def __delfield_pad(self): del self.__field_pad 
5516   
5517      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
5518   
5519 -    def iscontainer(self): 
5520          return True 
5521   
5522 -    def containerelements(self): 
5523          yield ('header', self.__field_header, None) 
5524          yield ('entry', self.__field_entry, None) 
5525          yield ('pad', self.__field_pad, None) 
5526   
5527   
5528   
5529   
5530 -class messagesentresponse(BaseProtogenClass): 
5531      __fields=['header', 'entry', 'pad'] 
5532   
5533 -    def __init__(self, *args, **kwargs): 
5534          dict={} 
5535          # What was supplied to this function 
5536          dict.update(kwargs) 
5537          # Parent constructor 
5538          super(messagesentresponse,self).__init__(**dict) 
5539          if self.__class__ is messagesentresponse: 
5540              self._update(args,dict) 
5541   
5542   
5543 -    def getfields(self): 
5544          return self.__fields 
5545   
5546   
5547 -    def _update(self, args, kwargs): 
5548          super(messagesentresponse,self)._update(args,kwargs) 
5549          keys=kwargs.keys() 
5550          for key in keys: 
5551              if key in self.__fields: 
5552                  setattr(self, key, kwargs[key]) 
5553                  del kwargs[key] 
5554          # Were any unrecognized kwargs passed in? 
5555          if __debug__: 
5556              self._complainaboutunusedargs(messagesentresponse,kwargs) 
5557          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
5558          # Make all P fields that haven't already been constructed 
5559   
5560   
5561 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
5562          'Writes this packet to the supplied buffer' 
5563          self._bufferstartoffset=buf.getcurrentoffset() 
5564          self.__field_header.writetobuffer(buf) 
5565          self.__field_entry.writetobuffer(buf) 
5566          self.__field_pad.writetobuffer(buf) 
5567          self._bufferendoffset=buf.getcurrentoffset() 
5568          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
5569   
5570   
5571 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
5572          'Reads this packet from the supplied buffer' 
5573          self._bufferstartoffset=buf.getcurrentoffset() 
5574          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
5575          self.__field_header=sanyoheader() 
5576          self.__field_header.readfrombuffer(buf) 
5577          self.__field_entry=messageentry() 
5578          self.__field_entry.readfrombuffer(buf) 
5579          self.__field_pad=UNKNOWN() 
5580          self.__field_pad.readfrombuffer(buf) 
5581          self._bufferendoffset=buf.getcurrentoffset() 
5582   
5583   
5584 -    def __getfield_header(self): 
5585          return self.__field_header.getvalue() 
5586   
5587 -    def __setfield_header(self, value): 
5588          if isinstance(value,sanyoheader): 
5589              self.__field_header=value 
5590          else: 
5591              self.__field_header=sanyoheader(value,) 
5592   
5593 -    def __delfield_header(self): del self.__field_header 
5594   
5595      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
5596   
5597 -    def __getfield_entry(self): 
5598          return self.__field_entry.getvalue() 
5599   
5600 -    def __setfield_entry(self, value): 
5601          if isinstance(value,messageentry): 
5602              self.__field_entry=value 
5603          else: 
5604              self.__field_entry=messageentry(value,) 
5605   
5606 -    def __delfield_entry(self): del self.__field_entry 
5607   
5608      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
5609   
5610 -    def __getfield_pad(self): 
5611          return self.__field_pad.getvalue() 
5612   
5613 -    def __setfield_pad(self, value): 
5614          if isinstance(value,UNKNOWN): 
5615              self.__field_pad=value 
5616          else: 
5617              self.__field_pad=UNKNOWN(value,) 
5618   
5619 -    def __delfield_pad(self): del self.__field_pad 
5620   
5621      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
5622   
5623 -    def iscontainer(self): 
5624          return True 
5625   
5626 -    def containerelements(self): 
5627          yield ('header', self.__field_header, None) 
5628          yield ('entry', self.__field_entry, None) 
5629          yield ('pad', self.__field_pad, None) 
5630   
5631   
5632   
5633   
5634 -class foldernamerequest(BaseProtogenClass): 
5635      __fields=['header', 'index', 'pad'] 
5636   
5637 -    def __init__(self, *args, **kwargs): 
5638          dict={} 
5639          # What was supplied to this function 
5640          dict.update(kwargs) 
5641          # Parent constructor 
5642          super(foldernamerequest,self).__init__(**dict) 
5643          if self.__class__ is foldernamerequest: 
5644              self._update(args,dict) 
5645   
5646   
5647 -    def getfields(self): 
5648          return self.__fields 
5649   
5650   
5651 -    def _update(self, args, kwargs): 
5652          super(foldernamerequest,self)._update(args,kwargs) 
5653          keys=kwargs.keys() 
5654          for key in keys: 
5655              if key in self.__fields: 
5656                  setattr(self, key, kwargs[key]) 
5657                  del kwargs[key] 
5658          # Were any unrecognized kwargs passed in? 
5659          if __debug__: 
5660              self._complainaboutunusedargs(foldernamerequest,kwargs) 
5661          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
5662          # Make all P fields that haven't already been constructed 
5663   
5664   
5665 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
5666          'Writes this packet to the supplied buffer' 
5667          self._bufferstartoffset=buf.getcurrentoffset() 
5668          try: self.__field_header 
5669          except: 
5670              self.__field_header=sanyoheader(**{'packettype': 0x0b, 'command': 0xef}) 
5671          self.__field_header.writetobuffer(buf) 
5672          self.__field_index.writetobuffer(buf) 
5673          try: self.__field_pad 
5674          except: 
5675              self.__field_pad=UNKNOWN(**{'sizeinbytes': 501}) 
5676          self.__field_pad.writetobuffer(buf) 
5677          self._bufferendoffset=buf.getcurrentoffset() 
5678          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
5679   
5680   
5681 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
5682          'Reads this packet from the supplied buffer' 
5683          self._bufferstartoffset=buf.getcurrentoffset() 
5684          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
5685          self.__field_header=sanyoheader(**{'packettype': 0x0b, 'command': 0xef}) 
5686          self.__field_header.readfrombuffer(buf) 
5687          self.__field_index=UINT(**{'sizeinbytes': 1}) 
5688          self.__field_index.readfrombuffer(buf) 
5689          self.__field_pad=UNKNOWN(**{'sizeinbytes': 501}) 
5690          self.__field_pad.readfrombuffer(buf) 
5691          self._bufferendoffset=buf.getcurrentoffset() 
5692   
5693   
5694 -    def __getfield_header(self): 
5695          try: self.__field_header 
5696          except: 
5697              self.__field_header=sanyoheader(**{'packettype': 0x0b, 'command': 0xef}) 
5698          return self.__field_header.getvalue() 
5699   
5700 -    def __setfield_header(self, value): 
5701          if isinstance(value,sanyoheader): 
5702              self.__field_header=value 
5703          else: 
5704              self.__field_header=sanyoheader(value,**{'packettype': 0x0b, 'command': 0xef}) 
5705   
5706 -    def __delfield_header(self): del self.__field_header 
5707   
5708      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
5709   
5710 -    def __getfield_index(self): 
5711          return self.__field_index.getvalue() 
5712   
5713 -    def __setfield_index(self, value): 
5714          if isinstance(value,UINT): 
5715              self.__field_index=value 
5716          else: 
5717              self.__field_index=UINT(value,**{'sizeinbytes': 1}) 
5718   
5719 -    def __delfield_index(self): del self.__field_index 
5720   
5721      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
5722   
5723 -    def __getfield_pad(self): 
5724          try: self.__field_pad 
5725          except: 
5726              self.__field_pad=UNKNOWN(**{'sizeinbytes': 501}) 
5727          return self.__field_pad.getvalue() 
5728   
5729 -    def __setfield_pad(self, value): 
5730          if isinstance(value,UNKNOWN): 
5731              self.__field_pad=value 
5732          else: 
5733              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 501}) 
5734   
5735 -    def __delfield_pad(self): del self.__field_pad 
5736   
5737      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
5738   
5739 -    def iscontainer(self): 
5740          return True 
5741   
5742 -    def containerelements(self): 
5743          yield ('header', self.__field_header, None) 
5744          yield ('index', self.__field_index, None) 
5745          yield ('pad', self.__field_pad, None) 
5746   
5747   
5748   
5749   
5750 -class foldernameentry(BaseProtogenClass): 
5751      __fields=['index', 'flag', 'autofile', 'notify', 'icon', 'name', 'pad', 'keyword'] 
5752   
5753 -    def __init__(self, *args, **kwargs): 
5754          dict={} 
5755          # What was supplied to this function 
5756          dict.update(kwargs) 
5757          # Parent constructor 
5758          super(foldernameentry,self).__init__(**dict) 
5759          if self.__class__ is foldernameentry: 
5760              self._update(args,dict) 
5761   
5762   
5763 -    def getfields(self): 
5764          return self.__fields 
5765   
5766   
5767 -    def _update(self, args, kwargs): 
5768          super(foldernameentry,self)._update(args,kwargs) 
5769          keys=kwargs.keys() 
5770          for key in keys: 
5771              if key in self.__fields: 
5772                  setattr(self, key, kwargs[key]) 
5773                  del kwargs[key] 
5774          # Were any unrecognized kwargs passed in? 
5775          if __debug__: 
5776              self._complainaboutunusedargs(foldernameentry,kwargs) 
5777          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
5778          # Make all P fields that haven't already been constructed 
5779   
5780   
5781 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
5782          'Writes this packet to the supplied buffer' 
5783          self._bufferstartoffset=buf.getcurrentoffset() 
5784          self.__field_index.writetobuffer(buf) 
5785          self.__field_flag.writetobuffer(buf) 
5786          self.__field_autofile.writetobuffer(buf) 
5787          self.__field_notify.writetobuffer(buf) 
5788          self.__field_icon.writetobuffer(buf) 
5789          self.__field_name.writetobuffer(buf) 
5790          try: self.__field_pad 
5791          except: 
5792              self.__field_pad=UNKNOWN(**{'sizeinbytes': 3}) 
5793          self.__field_pad.writetobuffer(buf) 
5794          self.__field_keyword.writetobuffer(buf) 
5795          self._bufferendoffset=buf.getcurrentoffset() 
5796          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
5797   
5798   
5799 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
5800          'Reads this packet from the supplied buffer' 
5801          self._bufferstartoffset=buf.getcurrentoffset() 
5802          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
5803          self.__field_index=UINT(**{'sizeinbytes': 1}) 
5804          self.__field_index.readfrombuffer(buf) 
5805          self.__field_flag=UINT(**{'sizeinbytes': 1}) 
5806          self.__field_flag.readfrombuffer(buf) 
5807          self.__field_autofile=UINT(**{'sizeinbytes': 1}) 
5808          self.__field_autofile.readfrombuffer(buf) 
5809          self.__field_notify=UINT(**{'sizeinbytes': 1}) 
5810          self.__field_notify.readfrombuffer(buf) 
5811          self.__field_icon=UINT(**{'sizeinbytes': 1}) 
5812          self.__field_icon.readfrombuffer(buf) 
5813          self.__field_name=USTRING(**{'sizeinbytes': 13, 'raiseonunterminatedread': False}) 
5814          self.__field_name.readfrombuffer(buf) 
5815          self.__field_pad=UNKNOWN(**{'sizeinbytes': 3}) 
5816          self.__field_pad.readfrombuffer(buf) 
5817          self.__field_keyword=USTRING(**{'sizeinbytes': 14, 'raiseonunterminatedread': False}) 
5818          self.__field_keyword.readfrombuffer(buf) 
5819          self._bufferendoffset=buf.getcurrentoffset() 
5820   
5821   
5822 -    def __getfield_index(self): 
5823          return self.__field_index.getvalue() 
5824   
5825 -    def __setfield_index(self, value): 
5826          if isinstance(value,UINT): 
5827              self.__field_index=value 
5828          else: 
5829              self.__field_index=UINT(value,**{'sizeinbytes': 1}) 
5830   
5831 -    def __delfield_index(self): del self.__field_index 
5832   
5833      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
5834   
5835 -    def __getfield_flag(self): 
5836          return self.__field_flag.getvalue() 
5837   
5838 -    def __setfield_flag(self, value): 
5839          if isinstance(value,UINT): 
5840              self.__field_flag=value 
5841          else: 
5842              self.__field_flag=UINT(value,**{'sizeinbytes': 1}) 
5843   
5844 -    def __delfield_flag(self): del self.__field_flag 
5845   
5846      flag=property(__getfield_flag, __setfield_flag, __delfield_flag, "0 if empty, 1 in use") 
5847   
5848 -    def __getfield_autofile(self): 
5849          return self.__field_autofile.getvalue() 
5850   
5851 -    def __setfield_autofile(self, value): 
5852          if isinstance(value,UINT): 
5853              self.__field_autofile=value 
5854          else: 
5855              self.__field_autofile=UINT(value,**{'sizeinbytes': 1}) 
5856   
5857 -    def __delfield_autofile(self): del self.__field_autofile 
5858   
5859      autofile=property(__getfield_autofile, __setfield_autofile, __delfield_autofile, "If 1, autofile messages with keyword") 
5860   
5861 -    def __getfield_notify(self): 
5862          return self.__field_notify.getvalue() 
5863   
5864 -    def __setfield_notify(self, value): 
5865          if isinstance(value,UINT): 
5866              self.__field_notify=value 
5867          else: 
5868              self.__field_notify=UINT(value,**{'sizeinbytes': 1}) 
5869   
5870 -    def __delfield_notify(self): del self.__field_notify 
5871   
5872      notify=property(__getfield_notify, __setfield_notify, __delfield_notify, None) 
5873   
5874 -    def __getfield_icon(self): 
5875          return self.__field_icon.getvalue() 
5876   
5877 -    def __setfield_icon(self, value): 
5878          if isinstance(value,UINT): 
5879              self.__field_icon=value 
5880          else: 
5881              self.__field_icon=UINT(value,**{'sizeinbytes': 1}) 
5882   
5883 -    def __delfield_icon(self): del self.__field_icon 
5884   
5885      icon=property(__getfield_icon, __setfield_icon, __delfield_icon, None) 
5886   
5887 -    def __getfield_name(self): 
5888          return self.__field_name.getvalue() 
5889   
5890 -    def __setfield_name(self, value): 
5891          if isinstance(value,USTRING): 
5892              self.__field_name=value 
5893          else: 
5894              self.__field_name=USTRING(value,**{'sizeinbytes': 13, 'raiseonunterminatedread': False}) 
5895   
5896 -    def __delfield_name(self): del self.__field_name 
5897   
5898      name=property(__getfield_name, __setfield_name, __delfield_name, "Name of the folder") 
5899   
5900 -    def __getfield_pad(self): 
5901          try: self.__field_pad 
5902          except: 
5903              self.__field_pad=UNKNOWN(**{'sizeinbytes': 3}) 
5904          return self.__field_pad.getvalue() 
5905   
5906 -    def __setfield_pad(self, value): 
5907          if isinstance(value,UNKNOWN): 
5908              self.__field_pad=value 
5909          else: 
5910              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 3}) 
5911   
5912 -    def __delfield_pad(self): del self.__field_pad 
5913   
5914      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
5915   
5916 -    def __getfield_keyword(self): 
5917          return self.__field_keyword.getvalue() 
5918   
5919 -    def __setfield_keyword(self, value): 
5920          if isinstance(value,USTRING): 
5921              self.__field_keyword=value 
5922          else: 
5923              self.__field_keyword=USTRING(value,**{'sizeinbytes': 14, 'raiseonunterminatedread': False}) 
5924   
5925 -    def __delfield_keyword(self): del self.__field_keyword 
5926   
5927      keyword=property(__getfield_keyword, __setfield_keyword, __delfield_keyword, None) 
5928   
5929 -    def iscontainer(self): 
5930          return True 
5931   
5932 -    def containerelements(self): 
5933          yield ('index', self.__field_index, None) 
5934          yield ('flag', self.__field_flag, "0 if empty, 1 in use") 
5935          yield ('autofile', self.__field_autofile, "If 1, autofile messages with keyword") 
5936          yield ('notify', self.__field_notify, None) 
5937          yield ('icon', self.__field_icon, None) 
5938          yield ('name', self.__field_name, "Name of the folder") 
5939          yield ('pad', self.__field_pad, None) 
5940          yield ('keyword', self.__field_keyword, None) 
5941   
5942   
5943   
5944   
5945 -class foldernameresponse(BaseProtogenClass): 
5946      __fields=['header', 'entry', 'pad'] 
5947   
5948 -    def __init__(self, *args, **kwargs): 
5949          dict={} 
5950          # What was supplied to this function 
5951          dict.update(kwargs) 
5952          # Parent constructor 
5953          super(foldernameresponse,self).__init__(**dict) 
5954          if self.__class__ is foldernameresponse: 
5955              self._update(args,dict) 
5956   
5957   
5958 -    def getfields(self): 
5959          return self.__fields 
5960   
5961   
5962 -    def _update(self, args, kwargs): 
5963          super(foldernameresponse,self)._update(args,kwargs) 
5964          keys=kwargs.keys() 
5965          for key in keys: 
5966              if key in self.__fields: 
5967                  setattr(self, key, kwargs[key]) 
5968                  del kwargs[key] 
5969          # Were any unrecognized kwargs passed in? 
5970          if __debug__: 
5971              self._complainaboutunusedargs(foldernameresponse,kwargs) 
5972          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
5973          # Make all P fields that haven't already been constructed 
5974   
5975   
5976 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
5977          'Writes this packet to the supplied buffer' 
5978          self._bufferstartoffset=buf.getcurrentoffset() 
5979          self.__field_header.writetobuffer(buf) 
5980          self.__field_entry.writetobuffer(buf) 
5981          self.__field_pad.writetobuffer(buf) 
5982          self._bufferendoffset=buf.getcurrentoffset() 
5983          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
5984   
5985   
5986 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
5987          'Reads this packet from the supplied buffer' 
5988          self._bufferstartoffset=buf.getcurrentoffset() 
5989          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
5990          self.__field_header=sanyoheader() 
5991          self.__field_header.readfrombuffer(buf) 
5992          self.__field_entry=foldernameentry() 
5993          self.__field_entry.readfrombuffer(buf) 
5994          self.__field_pad=UNKNOWN(**{'sizeinbytes': 467}) 
5995          self.__field_pad.readfrombuffer(buf) 
5996          self._bufferendoffset=buf.getcurrentoffset() 
5997   
5998   
5999 -    def __getfield_header(self): 
6000          return self.__field_header.getvalue() 
6001   
6002 -    def __setfield_header(self, value): 
6003          if isinstance(value,sanyoheader): 
6004              self.__field_header=value 
6005          else: 
6006              self.__field_header=sanyoheader(value,) 
6007   
6008 -    def __delfield_header(self): del self.__field_header 
6009   
6010      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
6011   
6012 -    def __getfield_entry(self): 
6013          return self.__field_entry.getvalue() 
6014   
6015 -    def __setfield_entry(self, value): 
6016          if isinstance(value,foldernameentry): 
6017              self.__field_entry=value 
6018          else: 
6019              self.__field_entry=foldernameentry(value,) 
6020   
6021 -    def __delfield_entry(self): del self.__field_entry 
6022   
6023      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
6024   
6025 -    def __getfield_pad(self): 
6026          return self.__field_pad.getvalue() 
6027   
6028 -    def __setfield_pad(self, value): 
6029          if isinstance(value,UNKNOWN): 
6030              self.__field_pad=value 
6031          else: 
6032              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 467}) 
6033   
6034 -    def __delfield_pad(self): del self.__field_pad 
6035   
6036      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
6037   
6038 -    def iscontainer(self): 
6039          return True 
6040   
6041 -    def containerelements(self): 
6042          yield ('header', self.__field_header, None) 
6043          yield ('entry', self.__field_entry, None) 
6044          yield ('pad', self.__field_pad, None) 
6045   
6046   
6047   
6048   
6049 -class todorequest(BaseProtogenClass): 
6050      __fields=['header', 'slot', 'pad'] 
6051   
6052 -    def __init__(self, *args, **kwargs): 
6053          dict={} 
6054          # What was supplied to this function 
6055          dict.update(kwargs) 
6056          # Parent constructor 
6057          super(todorequest,self).__init__(**dict) 
6058          if self.__class__ is todorequest: 
6059              self._update(args,dict) 
6060   
6061   
6062 -    def getfields(self): 
6063          return self.__fields 
6064   
6065   
6066 -    def _update(self, args, kwargs): 
6067          super(todorequest,self)._update(args,kwargs) 
6068          keys=kwargs.keys() 
6069          for key in keys: 
6070              if key in self.__fields: 
6071                  setattr(self, key, kwargs[key]) 
6072                  del kwargs[key] 
6073          # Were any unrecognized kwargs passed in? 
6074          if __debug__: 
6075              self._complainaboutunusedargs(todorequest,kwargs) 
6076          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
6077          # Make all P fields that haven't already been constructed 
6078   
6079   
6080 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
6081          'Writes this packet to the supplied buffer' 
6082          self._bufferstartoffset=buf.getcurrentoffset() 
6083          try: self.__field_header 
6084          except: 
6085              self.__field_header=sanyoheader(**{'packettype': 0x0c,'command': 0x25}) 
6086          self.__field_header.writetobuffer(buf) 
6087          self.__field_slot.writetobuffer(buf) 
6088          try: self.__field_pad 
6089          except: 
6090              self.__field_pad=UNKNOWN(**{'sizeinbytes': 501}) 
6091          self.__field_pad.writetobuffer(buf) 
6092          self._bufferendoffset=buf.getcurrentoffset() 
6093          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
6094   
6095   
6096 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
6097          'Reads this packet from the supplied buffer' 
6098          self._bufferstartoffset=buf.getcurrentoffset() 
6099          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
6100          self.__field_header=sanyoheader(**{'packettype': 0x0c,'command': 0x25}) 
6101          self.__field_header.readfrombuffer(buf) 
6102          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
6103          self.__field_slot.readfrombuffer(buf) 
6104          self.__field_pad=UNKNOWN(**{'sizeinbytes': 501}) 
6105          self.__field_pad.readfrombuffer(buf) 
6106          self._bufferendoffset=buf.getcurrentoffset() 
6107   
6108   
6109 -    def __getfield_header(self): 
6110          try: self.__field_header 
6111          except: 
6112              self.__field_header=sanyoheader(**{'packettype': 0x0c,'command': 0x25}) 
6113          return self.__field_header.getvalue() 
6114   
6115 -    def __setfield_header(self, value): 
6116          if isinstance(value,sanyoheader): 
6117              self.__field_header=value 
6118          else: 
6119              self.__field_header=sanyoheader(value,**{'packettype': 0x0c,'command': 0x25}) 
6120   
6121 -    def __delfield_header(self): del self.__field_header 
6122   
6123      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
6124   
6125 -    def __getfield_slot(self): 
6126          return self.__field_slot.getvalue() 
6127   
6128 -    def __setfield_slot(self, value): 
6129          if isinstance(value,UINT): 
6130              self.__field_slot=value 
6131          else: 
6132              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
6133   
6134 -    def __delfield_slot(self): del self.__field_slot 
6135   
6136      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
6137   
6138 -    def __getfield_pad(self): 
6139          try: self.__field_pad 
6140          except: 
6141              self.__field_pad=UNKNOWN(**{'sizeinbytes': 501}) 
6142          return self.__field_pad.getvalue() 
6143   
6144 -    def __setfield_pad(self, value): 
6145          if isinstance(value,UNKNOWN): 
6146              self.__field_pad=value 
6147          else: 
6148              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 501}) 
6149   
6150 -    def __delfield_pad(self): del self.__field_pad 
6151   
6152      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
6153   
6154 -    def iscontainer(self): 
6155          return True 
6156   
6157 -    def containerelements(self): 
6158          yield ('header', self.__field_header, None) 
6159          yield ('slot', self.__field_slot, None) 
6160          yield ('pad', self.__field_pad, None) 
6161   
6162   
6163   
6164   
6165 -class todoentry(BaseProtogenClass): 
6166      __fields=['slot', 'flag', 'todo', 'pad1', 'todo_len', 'priority', 'dunno', 'order'] 
6167   
6168 -    def __init__(self, *args, **kwargs): 
6169          dict={} 
6170          # What was supplied to this function 
6171          dict.update(kwargs) 
6172          # Parent constructor 
6173          super(todoentry,self).__init__(**dict) 
6174          if self.__class__ is todoentry: 
6175              self._update(args,dict) 
6176   
6177   
6178 -    def getfields(self): 
6179          return self.__fields 
6180   
6181   
6182 -    def _update(self, args, kwargs): 
6183          super(todoentry,self)._update(args,kwargs) 
6184          keys=kwargs.keys() 
6185          for key in keys: 
6186              if key in self.__fields: 
6187                  setattr(self, key, kwargs[key]) 
6188                  del kwargs[key] 
6189          # Were any unrecognized kwargs passed in? 
6190          if __debug__: 
6191              self._complainaboutunusedargs(todoentry,kwargs) 
6192          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
6193          # Make all P fields that haven't already been constructed 
6194   
6195   
6196 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
6197          'Writes this packet to the supplied buffer' 
6198          self._bufferstartoffset=buf.getcurrentoffset() 
6199          self.__field_slot.writetobuffer(buf) 
6200          self.__field_flag.writetobuffer(buf) 
6201          self.__field_todo.writetobuffer(buf) 
6202          try: self.__field_pad1 
6203          except: 
6204              self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7}) 
6205          self.__field_pad1.writetobuffer(buf) 
6206          self.__field_todo_len.writetobuffer(buf) 
6207          self.__field_priority.writetobuffer(buf) 
6208          try: self.__field_dunno 
6209          except: 
6210              self.__field_dunno=UINT(**{'sizeinbytes': 1}) 
6211          self.__field_dunno.writetobuffer(buf) 
6212          self.__field_order.writetobuffer(buf) 
6213          self._bufferendoffset=buf.getcurrentoffset() 
6214          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
6215   
6216   
6217 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
6218          'Reads this packet from the supplied buffer' 
6219          self._bufferstartoffset=buf.getcurrentoffset() 
6220          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
6221          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
6222          self.__field_slot.readfrombuffer(buf) 
6223          self.__field_flag=UINT(**{'sizeinbytes': 1}) 
6224          self.__field_flag.readfrombuffer(buf) 
6225          self.__field_todo=USTRING(**{'sizeinbytes': 14, 'raiseonunterminatedread': False}) 
6226          self.__field_todo.readfrombuffer(buf) 
6227          self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7}) 
6228          self.__field_pad1.readfrombuffer(buf) 
6229          self.__field_todo_len=UINT(**{'sizeinbytes': 1}) 
6230          self.__field_todo_len.readfrombuffer(buf) 
6231          self.__field_priority=UINT(**{'sizeinbytes': 1}) 
6232          self.__field_priority.readfrombuffer(buf) 
6233          self.__field_dunno=UINT(**{'sizeinbytes': 1}) 
6234          self.__field_dunno.readfrombuffer(buf) 
6235          self.__field_order=UINT(**{'sizeinbytes': 1}) 
6236          self.__field_order.readfrombuffer(buf) 
6237          self._bufferendoffset=buf.getcurrentoffset() 
6238   
6239   
6240 -    def __getfield_slot(self): 
6241          return self.__field_slot.getvalue() 
6242   
6243 -    def __setfield_slot(self, value): 
6244          if isinstance(value,UINT): 
6245              self.__field_slot=value 
6246          else: 
6247              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
6248   
6249 -    def __delfield_slot(self): del self.__field_slot 
6250   
6251      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
6252   
6253 -    def __getfield_flag(self): 
6254          return self.__field_flag.getvalue() 
6255   
6256 -    def __setfield_flag(self, value): 
6257          if isinstance(value,UINT): 
6258              self.__field_flag=value 
6259          else: 
6260              self.__field_flag=UINT(value,**{'sizeinbytes': 1}) 
6261   
6262 -    def __delfield_flag(self): del self.__field_flag 
6263   
6264      flag=property(__getfield_flag, __setfield_flag, __delfield_flag, "0: Not used, 1: Used") 
6265   
6266 -    def __getfield_todo(self): 
6267          return self.__field_todo.getvalue() 
6268   
6269 -    def __setfield_todo(self, value): 
6270          if isinstance(value,USTRING): 
6271              self.__field_todo=value 
6272          else: 
6273              self.__field_todo=USTRING(value,**{'sizeinbytes': 14, 'raiseonunterminatedread': False}) 
6274   
6275 -    def __delfield_todo(self): del self.__field_todo 
6276   
6277      todo=property(__getfield_todo, __setfield_todo, __delfield_todo, None) 
6278   
6279 -    def __getfield_pad1(self): 
6280          try: self.__field_pad1 
6281          except: 
6282              self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7}) 
6283          return self.__field_pad1.getvalue() 
6284   
6285 -    def __setfield_pad1(self, value): 
6286          if isinstance(value,UNKNOWN): 
6287              self.__field_pad1=value 
6288          else: 
6289              self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 7}) 
6290   
6291 -    def __delfield_pad1(self): del self.__field_pad1 
6292   
6293      pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None) 
6294   
6295 -    def __getfield_todo_len(self): 
6296          return self.__field_todo_len.getvalue() 
6297   
6298 -    def __setfield_todo_len(self, value): 
6299          if isinstance(value,UINT): 
6300              self.__field_todo_len=value 
6301          else: 
6302              self.__field_todo_len=UINT(value,**{'sizeinbytes': 1}) 
6303   
6304 -    def __delfield_todo_len(self): del self.__field_todo_len 
6305   
6306      todo_len=property(__getfield_todo_len, __setfield_todo_len, __delfield_todo_len, None) 
6307   
6308 -    def __getfield_priority(self): 
6309          return self.__field_priority.getvalue() 
6310   
6311 -    def __setfield_priority(self, value): 
6312          if isinstance(value,UINT): 
6313              self.__field_priority=value 
6314          else: 
6315              self.__field_priority=UINT(value,**{'sizeinbytes': 1}) 
6316   
6317 -    def __delfield_priority(self): del self.__field_priority 
6318   
6319      priority=property(__getfield_priority, __setfield_priority, __delfield_priority, "0: Normal, 1: Urgent, 2: Done") 
6320   
6321 -    def __getfield_dunno(self): 
6322          try: self.__field_dunno 
6323          except: 
6324              self.__field_dunno=UINT(**{'sizeinbytes': 1}) 
6325          return self.__field_dunno.getvalue() 
6326   
6327 -    def __setfield_dunno(self, value): 
6328          if isinstance(value,UINT): 
6329              self.__field_dunno=value 
6330          else: 
6331              self.__field_dunno=UINT(value,**{'sizeinbytes': 1}) 
6332   
6333 -    def __delfield_dunno(self): del self.__field_dunno 
6334   
6335      dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, "Maybe always zero") 
6336   
6337 -    def __getfield_order(self): 
6338          return self.__field_order.getvalue() 
6339   
6340 -    def __setfield_order(self, value): 
6341          if isinstance(value,UINT): 
6342              self.__field_order=value 
6343          else: 
6344              self.__field_order=UINT(value,**{'sizeinbytes': 1}) 
6345   
6346 -    def __delfield_order(self): del self.__field_order 
6347   
6348      order=property(__getfield_order, __setfield_order, __delfield_order, "Gets sorted on screen in this order") 
6349   
6350 -    def iscontainer(self): 
6351          return True 
6352   
6353 -    def containerelements(self): 
6354          yield ('slot', self.__field_slot, None) 
6355          yield ('flag', self.__field_flag, "0: Not used, 1: Used") 
6356          yield ('todo', self.__field_todo, None) 
6357          yield ('pad1', self.__field_pad1, None) 
6358          yield ('todo_len', self.__field_todo_len, None) 
6359          yield ('priority', self.__field_priority, "0: Normal, 1: Urgent, 2: Done") 
6360          yield ('dunno', self.__field_dunno, "Maybe always zero") 
6361          yield ('order', self.__field_order, "Gets sorted on screen in this order") 
6362   
6363   
6364   
6365   
6366 -class todoresponse(BaseProtogenClass): 
6367      __fields=['header', 'entry', 'pad'] 
6368   
6369 -    def __init__(self, *args, **kwargs): 
6370          dict={} 
6371          # What was supplied to this function 
6372          dict.update(kwargs) 
6373          # Parent constructor 
6374          super(todoresponse,self).__init__(**dict) 
6375          if self.__class__ is todoresponse: 
6376              self._update(args,dict) 
6377   
6378   
6379 -    def getfields(self): 
6380          return self.__fields 
6381   
6382   
6383 -    def _update(self, args, kwargs): 
6384          super(todoresponse,self)._update(args,kwargs) 
6385          keys=kwargs.keys() 
6386          for key in keys: 
6387              if key in self.__fields: 
6388                  setattr(self, key, kwargs[key]) 
6389                  del kwargs[key] 
6390          # Were any unrecognized kwargs passed in? 
6391          if __debug__: 
6392              self._complainaboutunusedargs(todoresponse,kwargs) 
6393          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
6394          # Make all P fields that haven't already been constructed 
6395   
6396   
6397 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
6398          'Writes this packet to the supplied buffer' 
6399          self._bufferstartoffset=buf.getcurrentoffset() 
6400          self.__field_header.writetobuffer(buf) 
6401          self.__field_entry.writetobuffer(buf) 
6402          self.__field_pad.writetobuffer(buf) 
6403          self._bufferendoffset=buf.getcurrentoffset() 
6404          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
6405   
6406   
6407 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
6408          'Reads this packet from the supplied buffer' 
6409          self._bufferstartoffset=buf.getcurrentoffset() 
6410          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
6411          self.__field_header=sanyoheader() 
6412          self.__field_header.readfrombuffer(buf) 
6413          self.__field_entry=todoentry() 
6414          self.__field_entry.readfrombuffer(buf) 
6415          self.__field_pad=UNKNOWN(**{'sizeinbytes': 472}) 
6416          self.__field_pad.readfrombuffer(buf) 
6417          self._bufferendoffset=buf.getcurrentoffset() 
6418   
6419   
6420 -    def __getfield_header(self): 
6421          return self.__field_header.getvalue() 
6422   
6423 -    def __setfield_header(self, value): 
6424          if isinstance(value,sanyoheader): 
6425              self.__field_header=value 
6426          else: 
6427              self.__field_header=sanyoheader(value,) 
6428   
6429 -    def __delfield_header(self): del self.__field_header 
6430   
6431      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
6432   
6433 -    def __getfield_entry(self): 
6434          return self.__field_entry.getvalue() 
6435   
6436 -    def __setfield_entry(self, value): 
6437          if isinstance(value,todoentry): 
6438              self.__field_entry=value 
6439          else: 
6440              self.__field_entry=todoentry(value,) 
6441   
6442 -    def __delfield_entry(self): del self.__field_entry 
6443   
6444      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
6445   
6446 -    def __getfield_pad(self): 
6447          return self.__field_pad.getvalue() 
6448   
6449 -    def __setfield_pad(self, value): 
6450          if isinstance(value,UNKNOWN): 
6451              self.__field_pad=value 
6452          else: 
6453              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 472}) 
6454   
6455 -    def __delfield_pad(self): del self.__field_pad 
6456   
6457      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
6458   
6459 -    def iscontainer(self): 
6460          return True 
6461   
6462 -    def containerelements(self): 
6463          yield ('header', self.__field_header, None) 
6464          yield ('entry', self.__field_entry, None) 
6465          yield ('pad', self.__field_pad, None) 
6466   
6467   
6468   
6469   
6470 -class historyrequest(BaseProtogenClass): 
6471      __fields=['type', 'header', 'header', 'header', 'slot', 'pad'] 
6472   
6473 -    def __init__(self, *args, **kwargs): 
6474          dict={} 
6475          # What was supplied to this function 
6476          dict.update(kwargs) 
6477          # Parent constructor 
6478          super(historyrequest,self).__init__(**dict) 
6479          if self.__class__ is historyrequest: 
6480              self._update(args,dict) 
6481   
6482   
6483 -    def getfields(self): 
6484          return self.__fields 
6485   
6486   
6487 -    def _update(self, args, kwargs): 
6488          super(historyrequest,self)._update(args,kwargs) 
6489          keys=kwargs.keys() 
6490          for key in keys: 
6491              if key in self.__fields: 
6492                  setattr(self, key, kwargs[key]) 
6493                  del kwargs[key] 
6494          # Were any unrecognized kwargs passed in? 
6495          if __debug__: 
6496              self._complainaboutunusedargs(historyrequest,kwargs) 
6497          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
6498          # Make all P fields that haven't already been constructed 
6499          try: self.__field_type 
6500          except: 
6501              self.__field_type=UINT() 
6502   
6503   
6504 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
6505          'Writes this packet to the supplied buffer' 
6506          self._bufferstartoffset=buf.getcurrentoffset() 
6507          if self.type==OUTGOING: 
6508              try: self.__field_header 
6509              except: 
6510                  self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x3d}) 
6511              self.__field_header.writetobuffer(buf) 
6512          if self.type==INCOMING: 
6513              try: self.__field_header 
6514              except: 
6515                  self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x3e}) 
6516              self.__field_header.writetobuffer(buf) 
6517          if self.type==MISSED: 
6518              try: self.__field_header 
6519              except: 
6520                  self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x3f}) 
6521              self.__field_header.writetobuffer(buf) 
6522          self.__field_slot.writetobuffer(buf) 
6523          try: self.__field_pad 
6524          except: 
6525              self.__field_pad=UNKNOWN(**{'sizeinbytes': 501}) 
6526          self.__field_pad.writetobuffer(buf) 
6527          self._bufferendoffset=buf.getcurrentoffset() 
6528          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
6529   
6530   
6531 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
6532          'Reads this packet from the supplied buffer' 
6533          self._bufferstartoffset=buf.getcurrentoffset() 
6534          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
6535          if self.type==OUTGOING: 
6536              self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x3d}) 
6537              self.__field_header.readfrombuffer(buf) 
6538          if self.type==INCOMING: 
6539              self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x3e}) 
6540              self.__field_header.readfrombuffer(buf) 
6541          if self.type==MISSED: 
6542              self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x3f}) 
6543              self.__field_header.readfrombuffer(buf) 
6544          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
6545          self.__field_slot.readfrombuffer(buf) 
6546          self.__field_pad=UNKNOWN(**{'sizeinbytes': 501}) 
6547          self.__field_pad.readfrombuffer(buf) 
6548          self._bufferendoffset=buf.getcurrentoffset() 
6549   
6550   
6551 -    def __getfield_type(self): 
6552          return self.__field_type.getvalue() 
6553   
6554 -    def __setfield_type(self, value): 
6555          if isinstance(value,UINT): 
6556              self.__field_type=value 
6557          else: 
6558              self.__field_type=UINT(value,) 
6559   
6560 -    def __delfield_type(self): del self.__field_type 
6561   
6562      type=property(__getfield_type, __setfield_type, __delfield_type, "0: Outgoing, 1: Incoming, 2: Missed") 
6563   
6564 -    def __getfield_header(self): 
6565          try: self.__field_header 
6566          except: 
6567              self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x3d}) 
6568          return self.__field_header.getvalue() 
6569   
6570 -    def __setfield_header(self, value): 
6571          if isinstance(value,sanyoheader): 
6572              self.__field_header=value 
6573          else: 
6574              self.__field_header=sanyoheader(value,**{'packettype': 0x0c, 'command': 0x3d}) 
6575   
6576 -    def __delfield_header(self): del self.__field_header 
6577   
6578      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
6579   
6580 -    def __getfield_header(self): 
6581          try: self.__field_header 
6582          except: 
6583              self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x3e}) 
6584          return self.__field_header.getvalue() 
6585   
6586 -    def __setfield_header(self, value): 
6587          if isinstance(value,sanyoheader): 
6588              self.__field_header=value 
6589          else: 
6590              self.__field_header=sanyoheader(value,**{'packettype': 0x0c, 'command': 0x3e}) 
6591   
6592 -    def __delfield_header(self): del self.__field_header 
6593   
6594      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
6595   
6596 -    def __getfield_header(self): 
6597          try: self.__field_header 
6598          except: 
6599              self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x3f}) 
6600          return self.__field_header.getvalue() 
6601   
6602 -    def __setfield_header(self, value): 
6603          if isinstance(value,sanyoheader): 
6604              self.__field_header=value 
6605          else: 
6606              self.__field_header=sanyoheader(value,**{'packettype': 0x0c, 'command': 0x3f}) 
6607   
6608 -    def __delfield_header(self): del self.__field_header 
6609   
6610      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
6611   
6612 -    def __getfield_slot(self): 
6613          return self.__field_slot.getvalue() 
6614   
6615 -    def __setfield_slot(self, value): 
6616          if isinstance(value,UINT): 
6617              self.__field_slot=value 
6618          else: 
6619              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
6620   
6621 -    def __delfield_slot(self): del self.__field_slot 
6622   
6623      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
6624   
6625 -    def __getfield_pad(self): 
6626          try: self.__field_pad 
6627          except: 
6628              self.__field_pad=UNKNOWN(**{'sizeinbytes': 501}) 
6629          return self.__field_pad.getvalue() 
6630   
6631 -    def __setfield_pad(self, value): 
6632          if isinstance(value,UNKNOWN): 
6633              self.__field_pad=value 
6634          else: 
6635              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 501}) 
6636   
6637 -    def __delfield_pad(self): del self.__field_pad 
6638   
6639      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
6640   
6641 -    def iscontainer(self): 
6642          return True 
6643   
6644 -    def containerelements(self): 
6645          yield ('type', self.__field_type, "0: Outgoing, 1: Incoming, 2: Missed") 
6646          if self.type==OUTGOING: 
6647              yield ('header', self.__field_header, None) 
6648          if self.type==INCOMING: 
6649              yield ('header', self.__field_header, None) 
6650          if self.type==MISSED: 
6651              yield ('header', self.__field_header, None) 
6652          yield ('slot', self.__field_slot, None) 
6653          yield ('pad', self.__field_pad, None) 
6654   
6655   
6656   
6657   
6658 -class historyentry(BaseProtogenClass): 
6659      __fields=['slot', 'date', 'phonenumlen', 'phonenum', 'name'] 
6660   
6661 -    def __init__(self, *args, **kwargs): 
6662          dict={} 
6663          # What was supplied to this function 
6664          dict.update(kwargs) 
6665          # Parent constructor 
6666          super(historyentry,self).__init__(**dict) 
6667          if self.__class__ is historyentry: 
6668              self._update(args,dict) 
6669   
6670   
6671 -    def getfields(self): 
6672          return self.__fields 
6673   
6674   
6675 -    def _update(self, args, kwargs): 
6676          super(historyentry,self)._update(args,kwargs) 
6677          keys=kwargs.keys() 
6678          for key in keys: 
6679              if key in self.__fields: 
6680                  setattr(self, key, kwargs[key]) 
6681                  del kwargs[key] 
6682          # Were any unrecognized kwargs passed in? 
6683          if __debug__: 
6684              self._complainaboutunusedargs(historyentry,kwargs) 
6685          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
6686          # Make all P fields that haven't already been constructed 
6687   
6688   
6689 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
6690          'Writes this packet to the supplied buffer' 
6691          self._bufferstartoffset=buf.getcurrentoffset() 
6692          self.__field_slot.writetobuffer(buf) 
6693          self.__field_date.writetobuffer(buf) 
6694          self.__field_phonenumlen.writetobuffer(buf) 
6695          self.__field_phonenum.writetobuffer(buf) 
6696          self.__field_name.writetobuffer(buf) 
6697          self._bufferendoffset=buf.getcurrentoffset() 
6698          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
6699   
6700   
6701 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
6702          'Reads this packet from the supplied buffer' 
6703          self._bufferstartoffset=buf.getcurrentoffset() 
6704          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
6705          self.__field_slot=UINT(**{'sizeinbytes': 2}) 
6706          self.__field_slot.readfrombuffer(buf) 
6707          self.__field_date=GPSDATE(**{'sizeinbytes': 4}) 
6708          self.__field_date.readfrombuffer(buf) 
6709          self.__field_phonenumlen=UINT(**{'sizeinbytes': 1}) 
6710          self.__field_phonenumlen.readfrombuffer(buf) 
6711          self.__field_phonenum=USTRING(**{'sizeinbytes': 48, 'raiseonunterminatedread': False}) 
6712          self.__field_phonenum.readfrombuffer(buf) 
6713          self.__field_name=USTRING(**{'sizeinbytes': 16, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
6714          self.__field_name.readfrombuffer(buf) 
6715          self._bufferendoffset=buf.getcurrentoffset() 
6716   
6717   
6718 -    def __getfield_slot(self): 
6719          return self.__field_slot.getvalue() 
6720   
6721 -    def __setfield_slot(self, value): 
6722          if isinstance(value,UINT): 
6723              self.__field_slot=value 
6724          else: 
6725              self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 
6726   
6727 -    def __delfield_slot(self): del self.__field_slot 
6728   
6729      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
6730   
6731 -    def __getfield_date(self): 
6732          return self.__field_date.getvalue() 
6733   
6734 -    def __setfield_date(self, value): 
6735          if isinstance(value,GPSDATE): 
6736              self.__field_date=value 
6737          else: 
6738              self.__field_date=GPSDATE(value,**{'sizeinbytes': 4}) 
6739   
6740 -    def __delfield_date(self): del self.__field_date 
6741   
6742      date=property(__getfield_date, __setfield_date, __delfield_date, None) 
6743   
6744 -    def __getfield_phonenumlen(self): 
6745          return self.__field_phonenumlen.getvalue() 
6746   
6747 -    def __setfield_phonenumlen(self, value): 
6748          if isinstance(value,UINT): 
6749              self.__field_phonenumlen=value 
6750          else: 
6751              self.__field_phonenumlen=UINT(value,**{'sizeinbytes': 1}) 
6752   
6753 -    def __delfield_phonenumlen(self): del self.__field_phonenumlen 
6754   
6755      phonenumlen=property(__getfield_phonenumlen, __setfield_phonenumlen, __delfield_phonenumlen, None) 
6756   
6757 -    def __getfield_phonenum(self): 
6758          return self.__field_phonenum.getvalue() 
6759   
6760 -    def __setfield_phonenum(self, value): 
6761          if isinstance(value,USTRING): 
6762              self.__field_phonenum=value 
6763          else: 
6764              self.__field_phonenum=USTRING(value,**{'sizeinbytes': 48, 'raiseonunterminatedread': False}) 
6765   
6766 -    def __delfield_phonenum(self): del self.__field_phonenum 
6767   
6768      phonenum=property(__getfield_phonenum, __setfield_phonenum, __delfield_phonenum, None) 
6769   
6770 -    def __getfield_name(self): 
6771          return self.__field_name.getvalue() 
6772   
6773 -    def __setfield_name(self, value): 
6774          if isinstance(value,USTRING): 
6775              self.__field_name=value 
6776          else: 
6777              self.__field_name=USTRING(value,**{'sizeinbytes': 16, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
6778   
6779 -    def __delfield_name(self): del self.__field_name 
6780   
6781      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
6782   
6783 -    def iscontainer(self): 
6784          return True 
6785   
6786 -    def containerelements(self): 
6787          yield ('slot', self.__field_slot, None) 
6788          yield ('date', self.__field_date, None) 
6789          yield ('phonenumlen', self.__field_phonenumlen, None) 
6790          yield ('phonenum', self.__field_phonenum, None) 
6791          yield ('name', self.__field_name, None) 
6792   
6793   
6794   
6795   
6796 -class historyresponse(BaseProtogenClass): 
6797      __fields=['header', 'entry'] 
6798   
6799 -    def __init__(self, *args, **kwargs): 
6800          dict={} 
6801          # What was supplied to this function 
6802          dict.update(kwargs) 
6803          # Parent constructor 
6804          super(historyresponse,self).__init__(**dict) 
6805          if self.__class__ is historyresponse: 
6806              self._update(args,dict) 
6807   
6808   
6809 -    def getfields(self): 
6810          return self.__fields 
6811   
6812   
6813 -    def _update(self, args, kwargs): 
6814          super(historyresponse,self)._update(args,kwargs) 
6815          keys=kwargs.keys() 
6816          for key in keys: 
6817              if key in self.__fields: 
6818                  setattr(self, key, kwargs[key]) 
6819                  del kwargs[key] 
6820          # Were any unrecognized kwargs passed in? 
6821          if __debug__: 
6822              self._complainaboutunusedargs(historyresponse,kwargs) 
6823          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
6824          # Make all P fields that haven't already been constructed 
6825   
6826   
6827 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
6828          'Writes this packet to the supplied buffer' 
6829          self._bufferstartoffset=buf.getcurrentoffset() 
6830          self.__field_header.writetobuffer(buf) 
6831          self.__field_entry.writetobuffer(buf) 
6832          self._bufferendoffset=buf.getcurrentoffset() 
6833          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
6834   
6835   
6836 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
6837          'Reads this packet from the supplied buffer' 
6838          self._bufferstartoffset=buf.getcurrentoffset() 
6839          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
6840          self.__field_header=sanyoheader() 
6841          self.__field_header.readfrombuffer(buf) 
6842          self.__field_entry=historyentry() 
6843          self.__field_entry.readfrombuffer(buf) 
6844          self._bufferendoffset=buf.getcurrentoffset() 
6845   
6846   
6847 -    def __getfield_header(self): 
6848          return self.__field_header.getvalue() 
6849   
6850 -    def __setfield_header(self, value): 
6851          if isinstance(value,sanyoheader): 
6852              self.__field_header=value 
6853          else: 
6854              self.__field_header=sanyoheader(value,) 
6855   
6856 -    def __delfield_header(self): del self.__field_header 
6857   
6858      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
6859   
6860 -    def __getfield_entry(self): 
6861          return self.__field_entry.getvalue() 
6862   
6863 -    def __setfield_entry(self, value): 
6864          if isinstance(value,historyentry): 
6865              self.__field_entry=value 
6866          else: 
6867              self.__field_entry=historyentry(value,) 
6868   
6869 -    def __delfield_entry(self): del self.__field_entry 
6870   
6871      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
6872   
6873 -    def iscontainer(self): 
6874          return True 
6875   
6876 -    def containerelements(self): 
6877          yield ('header', self.__field_header, None) 
6878          yield ('entry', self.__field_entry, None) 
6879