Source Code for Module phones.p_toshibavm4050

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