Source Code for Module phones.p_samsungspha900

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