Source Code for Module phones.p_samsungsphn400

   1  # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE 
   2   
   3  """Various descriptions of data specific to Sanyo phones""" 
   4   
   5  from prototypes import * 
   6   
   7  # We use LSB for all integer like fields 
   8   
   9  UINT=UINTlsb 
  10  BOOL=BOOLlsb 
  11   
  12 -class getphonestatus(BaseProtogenClass): 
  13      __fields=['command'] 
  14   
  15 -    def __init__(self, *args, **kwargs): 
  16          dict={} 
  17          # What was supplied to this function 
  18          dict.update(kwargs) 
  19          # Parent constructor 
  20          super(getphonestatus,self).__init__(**dict) 
  21          if self.__class__ is getphonestatus: 
  22              self._update(args,dict) 
  23   
  24   
  25 -    def getfields(self): 
  26          return self.__fields 
  27   
  28   
  29 -    def _update(self, args, kwargs): 
  30          super(getphonestatus,self)._update(args,kwargs) 
  31          keys=kwargs.keys() 
  32          for key in keys: 
  33              if key in self.__fields: 
  34                  setattr(self, key, kwargs[key]) 
  35                  del kwargs[key] 
  36          # Were any unrecognized kwargs passed in? 
  37          if __debug__: 
  38              self._complainaboutunusedargs(getphonestatus,kwargs) 
  39          if len(args): 
  40              dict2={'sizeinbytes': 1, 'constant': 0x0c} 
  41              dict2.update(kwargs) 
  42              kwargs=dict2 
  43              self.__field_command=UINT(*args,**dict2) 
  44          # Make all P fields that haven't already been constructed 
  45   
  46   
  47 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
  48          'Writes this packet to the supplied buffer' 
  49          self._bufferstartoffset=buf.getcurrentoffset() 
  50          try: self.__field_command 
  51          except: 
  52              self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x0c}) 
  53          self.__field_command.writetobuffer(buf) 
  54          self._bufferendoffset=buf.getcurrentoffset() 
  55          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
  56   
  57   
  58 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
  59          'Reads this packet from the supplied buffer' 
  60          self._bufferstartoffset=buf.getcurrentoffset() 
  61          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
  62          self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x0c}) 
  63          self.__field_command.readfrombuffer(buf) 
  64          self._bufferendoffset=buf.getcurrentoffset() 
  65   
  66   
  67 -    def __getfield_command(self): 
  68          try: self.__field_command 
  69          except: 
  70              self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x0c}) 
  71          return self.__field_command.getvalue() 
  72   
  73 -    def __setfield_command(self, value): 
  74          if isinstance(value,UINT): 
  75              self.__field_command=value 
  76          else: 
  77              self.__field_command=UINT(value,**{'sizeinbytes': 1, 'constant': 0x0c}) 
  78   
  79 -    def __delfield_command(self): del self.__field_command 
  80   
  81      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
  82   
  83 -    def iscontainer(self): 
  84          return True 
  85   
  86 -    def containerelements(self): 
  87          yield ('command', self.__field_command, None) 
  88   
  89   
  90   
  91   
  92 -class getphoneresponse(BaseProtogenClass): 
  93      __fields=['pad'] 
  94   
  95 -    def __init__(self, *args, **kwargs): 
  96          dict={} 
  97          # What was supplied to this function 
  98          dict.update(kwargs) 
  99          # Parent constructor 
 100          super(getphoneresponse,self).__init__(**dict) 
 101          if self.__class__ is getphoneresponse: 
 102              self._update(args,dict) 
 103   
 104   
 105 -    def getfields(self): 
 106          return self.__fields 
 107   
 108   
 109 -    def _update(self, args, kwargs): 
 110          super(getphoneresponse,self)._update(args,kwargs) 
 111          keys=kwargs.keys() 
 112          for key in keys: 
 113              if key in self.__fields: 
 114                  setattr(self, key, kwargs[key]) 
 115                  del kwargs[key] 
 116          # Were any unrecognized kwargs passed in? 
 117          if __debug__: 
 118              self._complainaboutunusedargs(getphoneresponse,kwargs) 
 119          if len(args): 
 120              dict2={} 
 121              dict2.update(kwargs) 
 122              kwargs=dict2 
 123              self.__field_pad=UNKNOWN(*args,**dict2) 
 124          # Make all P fields that haven't already been constructed 
 125   
 126   
 127 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 128          'Writes this packet to the supplied buffer' 
 129          self._bufferstartoffset=buf.getcurrentoffset() 
 130          self.__field_pad.writetobuffer(buf) 
 131          self._bufferendoffset=buf.getcurrentoffset() 
 132          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 133   
 134   
 135 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 136          'Reads this packet from the supplied buffer' 
 137          self._bufferstartoffset=buf.getcurrentoffset() 
 138          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 139          self.__field_pad=UNKNOWN() 
 140          self.__field_pad.readfrombuffer(buf) 
 141          self._bufferendoffset=buf.getcurrentoffset() 
 142   
 143   
 144 -    def __getfield_pad(self): 
 145          return self.__field_pad.getvalue() 
 146   
 147 -    def __setfield_pad(self, value): 
 148          if isinstance(value,UNKNOWN): 
 149              self.__field_pad=value 
 150          else: 
 151              self.__field_pad=UNKNOWN(value,) 
 152   
 153 -    def __delfield_pad(self): del self.__field_pad 
 154   
 155      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
 156   
 157 -    def iscontainer(self): 
 158          return True 
 159   
 160 -    def containerelements(self): 
 161          yield ('pad', self.__field_pad, None) 
 162   
 163   
 164   
 165   
 166 -class firmwarerequest(BaseProtogenClass): 
 167      __fields=['command'] 
 168   
 169 -    def __init__(self, *args, **kwargs): 
 170          dict={} 
 171          # What was supplied to this function 
 172          dict.update(kwargs) 
 173          # Parent constructor 
 174          super(firmwarerequest,self).__init__(**dict) 
 175          if self.__class__ is firmwarerequest: 
 176              self._update(args,dict) 
 177   
 178   
 179 -    def getfields(self): 
 180          return self.__fields 
 181   
 182   
 183 -    def _update(self, args, kwargs): 
 184          super(firmwarerequest,self)._update(args,kwargs) 
 185          keys=kwargs.keys() 
 186          for key in keys: 
 187              if key in self.__fields: 
 188                  setattr(self, key, kwargs[key]) 
 189                  del kwargs[key] 
 190          # Were any unrecognized kwargs passed in? 
 191          if __debug__: 
 192              self._complainaboutunusedargs(firmwarerequest,kwargs) 
 193          if len(args): 
 194              dict2={'sizeinbytes': 1, 'constant': 0x00} 
 195              dict2.update(kwargs) 
 196              kwargs=dict2 
 197              self.__field_command=UINT(*args,**dict2) 
 198          # Make all P fields that haven't already been constructed 
 199   
 200   
 201 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 202          'Writes this packet to the supplied buffer' 
 203          self._bufferstartoffset=buf.getcurrentoffset() 
 204          try: self.__field_command 
 205          except: 
 206              self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 
 207          self.__field_command.writetobuffer(buf) 
 208          self._bufferendoffset=buf.getcurrentoffset() 
 209          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 210   
 211   
 212 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 213          'Reads this packet from the supplied buffer' 
 214          self._bufferstartoffset=buf.getcurrentoffset() 
 215          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 216          self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 
 217          self.__field_command.readfrombuffer(buf) 
 218          self._bufferendoffset=buf.getcurrentoffset() 
 219   
 220   
 221 -    def __getfield_command(self): 
 222          try: self.__field_command 
 223          except: 
 224              self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 
 225          return self.__field_command.getvalue() 
 226   
 227 -    def __setfield_command(self, value): 
 228          if isinstance(value,UINT): 
 229              self.__field_command=value 
 230          else: 
 231              self.__field_command=UINT(value,**{'sizeinbytes': 1, 'constant': 0x00}) 
 232   
 233 -    def __delfield_command(self): del self.__field_command 
 234   
 235      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
 236   
 237 -    def iscontainer(self): 
 238          return True 
 239   
 240 -    def containerelements(self): 
 241          yield ('command', self.__field_command, None) 
 242   
 243   
 244   
 245   
 246 -class firmwareresponse(BaseProtogenClass): 
 247      __fields=['command', 'date1', 'time1', 'date2', 'time2', 'string1', 'dunno1'] 
 248   
 249 -    def __init__(self, *args, **kwargs): 
 250          dict={} 
 251          # What was supplied to this function 
 252          dict.update(kwargs) 
 253          # Parent constructor 
 254          super(firmwareresponse,self).__init__(**dict) 
 255          if self.__class__ is firmwareresponse: 
 256              self._update(args,dict) 
 257   
 258   
 259 -    def getfields(self): 
 260          return self.__fields 
 261   
 262   
 263 -    def _update(self, args, kwargs): 
 264          super(firmwareresponse,self)._update(args,kwargs) 
 265          keys=kwargs.keys() 
 266          for key in keys: 
 267              if key in self.__fields: 
 268                  setattr(self, key, kwargs[key]) 
 269                  del kwargs[key] 
 270          # Were any unrecognized kwargs passed in? 
 271          if __debug__: 
 272              self._complainaboutunusedargs(firmwareresponse,kwargs) 
 273          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 274          # Make all P fields that haven't already been constructed 
 275   
 276   
 277 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 278          'Writes this packet to the supplied buffer' 
 279          self._bufferstartoffset=buf.getcurrentoffset() 
 280          self.__field_command.writetobuffer(buf) 
 281          self.__field_date1.writetobuffer(buf) 
 282          self.__field_time1.writetobuffer(buf) 
 283          self.__field_date2.writetobuffer(buf) 
 284          self.__field_time2.writetobuffer(buf) 
 285          self.__field_string1.writetobuffer(buf) 
 286          self.__field_dunno1.writetobuffer(buf) 
 287          self._bufferendoffset=buf.getcurrentoffset() 
 288          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 289   
 290   
 291 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 292          'Reads this packet from the supplied buffer' 
 293          self._bufferstartoffset=buf.getcurrentoffset() 
 294          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 295          self.__field_command=UINT(**{'sizeinbytes': 1}) 
 296          self.__field_command.readfrombuffer(buf) 
 297          self.__field_date1=USTRING(**{'sizeinbytes': 11, 'terminator': None}) 
 298          self.__field_date1.readfrombuffer(buf) 
 299          self.__field_time1=USTRING(**{'sizeinbytes': 8, 'terminator': None}) 
 300          self.__field_time1.readfrombuffer(buf) 
 301          self.__field_date2=USTRING(**{'sizeinbytes': 11, 'terminator': None}) 
 302          self.__field_date2.readfrombuffer(buf) 
 303          self.__field_time2=USTRING(**{'sizeinbytes': 8, 'terminator': None}) 
 304          self.__field_time2.readfrombuffer(buf) 
 305          self.__field_string1=USTRING(**{'sizeinbytes': 8, 'terminator': None}) 
 306          self.__field_string1.readfrombuffer(buf) 
 307          self.__field_dunno1=UNKNOWN(**{'sizeinbytes': 8}) 
 308          self.__field_dunno1.readfrombuffer(buf) 
 309          self._bufferendoffset=buf.getcurrentoffset() 
 310   
 311   
 312 -    def __getfield_command(self): 
 313          return self.__field_command.getvalue() 
 314   
 315 -    def __setfield_command(self, value): 
 316          if isinstance(value,UINT): 
 317              self.__field_command=value 
 318          else: 
 319              self.__field_command=UINT(value,**{'sizeinbytes': 1}) 
 320   
 321 -    def __delfield_command(self): del self.__field_command 
 322   
 323      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
 324   
 325 -    def __getfield_date1(self): 
 326          return self.__field_date1.getvalue() 
 327   
 328 -    def __setfield_date1(self, value): 
 329          if isinstance(value,USTRING): 
 330              self.__field_date1=value 
 331          else: 
 332              self.__field_date1=USTRING(value,**{'sizeinbytes': 11, 'terminator': None}) 
 333   
 334 -    def __delfield_date1(self): del self.__field_date1 
 335   
 336      date1=property(__getfield_date1, __setfield_date1, __delfield_date1, None) 
 337   
 338 -    def __getfield_time1(self): 
 339          return self.__field_time1.getvalue() 
 340   
 341 -    def __setfield_time1(self, value): 
 342          if isinstance(value,USTRING): 
 343              self.__field_time1=value 
 344          else: 
 345              self.__field_time1=USTRING(value,**{'sizeinbytes': 8, 'terminator': None}) 
 346   
 347 -    def __delfield_time1(self): del self.__field_time1 
 348   
 349      time1=property(__getfield_time1, __setfield_time1, __delfield_time1, None) 
 350   
 351 -    def __getfield_date2(self): 
 352          return self.__field_date2.getvalue() 
 353   
 354 -    def __setfield_date2(self, value): 
 355          if isinstance(value,USTRING): 
 356              self.__field_date2=value 
 357          else: 
 358              self.__field_date2=USTRING(value,**{'sizeinbytes': 11, 'terminator': None}) 
 359   
 360 -    def __delfield_date2(self): del self.__field_date2 
 361   
 362      date2=property(__getfield_date2, __setfield_date2, __delfield_date2, None) 
 363   
 364 -    def __getfield_time2(self): 
 365          return self.__field_time2.getvalue() 
 366   
 367 -    def __setfield_time2(self, value): 
 368          if isinstance(value,USTRING): 
 369              self.__field_time2=value 
 370          else: 
 371              self.__field_time2=USTRING(value,**{'sizeinbytes': 8, 'terminator': None}) 
 372   
 373 -    def __delfield_time2(self): del self.__field_time2 
 374   
 375      time2=property(__getfield_time2, __setfield_time2, __delfield_time2, None) 
 376   
 377 -    def __getfield_string1(self): 
 378          return self.__field_string1.getvalue() 
 379   
 380 -    def __setfield_string1(self, value): 
 381          if isinstance(value,USTRING): 
 382              self.__field_string1=value 
 383          else: 
 384              self.__field_string1=USTRING(value,**{'sizeinbytes': 8, 'terminator': None}) 
 385   
 386 -    def __delfield_string1(self): del self.__field_string1 
 387   
 388      string1=property(__getfield_string1, __setfield_string1, __delfield_string1, None) 
 389   
 390 -    def __getfield_dunno1(self): 
 391          return self.__field_dunno1.getvalue() 
 392   
 393 -    def __setfield_dunno1(self, value): 
 394          if isinstance(value,UNKNOWN): 
 395              self.__field_dunno1=value 
 396          else: 
 397              self.__field_dunno1=UNKNOWN(value,**{'sizeinbytes': 8}) 
 398   
 399 -    def __delfield_dunno1(self): del self.__field_dunno1 
 400   
 401      dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None) 
 402   
 403 -    def iscontainer(self): 
 404          return True 
 405   
 406 -    def containerelements(self): 
 407          yield ('command', self.__field_command, None) 
 408          yield ('date1', self.__field_date1, None) 
 409          yield ('time1', self.__field_time1, None) 
 410          yield ('date2', self.__field_date2, None) 
 411          yield ('time2', self.__field_time2, None) 
 412          yield ('string1', self.__field_string1, None) 
 413          yield ('dunno1', self.__field_dunno1, None) 
 414   
 415   
 416   
 417   
 418 -class esnrequest(BaseProtogenClass): 
 419      __fields=['command'] 
 420   
 421 -    def __init__(self, *args, **kwargs): 
 422          dict={} 
 423          # What was supplied to this function 
 424          dict.update(kwargs) 
 425          # Parent constructor 
 426          super(esnrequest,self).__init__(**dict) 
 427          if self.__class__ is esnrequest: 
 428              self._update(args,dict) 
 429   
 430   
 431 -    def getfields(self): 
 432          return self.__fields 
 433   
 434   
 435 -    def _update(self, args, kwargs): 
 436          super(esnrequest,self)._update(args,kwargs) 
 437          keys=kwargs.keys() 
 438          for key in keys: 
 439              if key in self.__fields: 
 440                  setattr(self, key, kwargs[key]) 
 441                  del kwargs[key] 
 442          # Were any unrecognized kwargs passed in? 
 443          if __debug__: 
 444              self._complainaboutunusedargs(esnrequest,kwargs) 
 445          if len(args): 
 446              dict2={'sizeinbytes': 1, 'constant': 0x01} 
 447              dict2.update(kwargs) 
 448              kwargs=dict2 
 449              self.__field_command=UINT(*args,**dict2) 
 450          # Make all P fields that haven't already been constructed 
 451   
 452   
 453 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 454          'Writes this packet to the supplied buffer' 
 455          self._bufferstartoffset=buf.getcurrentoffset() 
 456          try: self.__field_command 
 457          except: 
 458              self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x01}) 
 459          self.__field_command.writetobuffer(buf) 
 460          self._bufferendoffset=buf.getcurrentoffset() 
 461          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 462   
 463   
 464 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 465          'Reads this packet from the supplied buffer' 
 466          self._bufferstartoffset=buf.getcurrentoffset() 
 467          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 468          self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x01}) 
 469          self.__field_command.readfrombuffer(buf) 
 470          self._bufferendoffset=buf.getcurrentoffset() 
 471   
 472   
 473 -    def __getfield_command(self): 
 474          try: self.__field_command 
 475          except: 
 476              self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x01}) 
 477          return self.__field_command.getvalue() 
 478   
 479 -    def __setfield_command(self, value): 
 480          if isinstance(value,UINT): 
 481              self.__field_command=value 
 482          else: 
 483              self.__field_command=UINT(value,**{'sizeinbytes': 1, 'constant': 0x01}) 
 484   
 485 -    def __delfield_command(self): del self.__field_command 
 486   
 487      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
 488   
 489 -    def iscontainer(self): 
 490          return True 
 491   
 492 -    def containerelements(self): 
 493          yield ('command', self.__field_command, None) 
 494   
 495   
 496   
 497   
 498 -class beginendupdaterequest(BaseProtogenClass): 
 499      __fields=['command', 'beginend'] 
 500   
 501 -    def __init__(self, *args, **kwargs): 
 502          dict={} 
 503          # What was supplied to this function 
 504          dict.update(kwargs) 
 505          # Parent constructor 
 506          super(beginendupdaterequest,self).__init__(**dict) 
 507          if self.__class__ is beginendupdaterequest: 
 508              self._update(args,dict) 
 509   
 510   
 511 -    def getfields(self): 
 512          return self.__fields 
 513   
 514   
 515 -    def _update(self, args, kwargs): 
 516          super(beginendupdaterequest,self)._update(args,kwargs) 
 517          keys=kwargs.keys() 
 518          for key in keys: 
 519              if key in self.__fields: 
 520                  setattr(self, key, kwargs[key]) 
 521                  del kwargs[key] 
 522          # Were any unrecognized kwargs passed in? 
 523          if __debug__: 
 524              self._complainaboutunusedargs(beginendupdaterequest,kwargs) 
 525          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 526          # Make all P fields that haven't already been constructed 
 527   
 528   
 529 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 530          'Writes this packet to the supplied buffer' 
 531          self._bufferstartoffset=buf.getcurrentoffset() 
 532          try: self.__field_command 
 533          except: 
 534              self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x29}) 
 535          self.__field_command.writetobuffer(buf) 
 536          self.__field_beginend.writetobuffer(buf) 
 537          self._bufferendoffset=buf.getcurrentoffset() 
 538          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 539   
 540   
 541 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 542          'Reads this packet from the supplied buffer' 
 543          self._bufferstartoffset=buf.getcurrentoffset() 
 544          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 545          self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x29}) 
 546          self.__field_command.readfrombuffer(buf) 
 547          self.__field_beginend=UINT(**{'sizeinbytes': 1}) 
 548          self.__field_beginend.readfrombuffer(buf) 
 549          self._bufferendoffset=buf.getcurrentoffset() 
 550   
 551   
 552 -    def __getfield_command(self): 
 553          try: self.__field_command 
 554          except: 
 555              self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x29}) 
 556          return self.__field_command.getvalue() 
 557   
 558 -    def __setfield_command(self, value): 
 559          if isinstance(value,UINT): 
 560              self.__field_command=value 
 561          else: 
 562              self.__field_command=UINT(value,**{'sizeinbytes': 1, 'constant': 0x29}) 
 563   
 564 -    def __delfield_command(self): del self.__field_command 
 565   
 566      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
 567   
 568 -    def __getfield_beginend(self): 
 569          return self.__field_beginend.getvalue() 
 570   
 571 -    def __setfield_beginend(self, value): 
 572          if isinstance(value,UINT): 
 573              self.__field_beginend=value 
 574          else: 
 575              self.__field_beginend=UINT(value,**{'sizeinbytes': 1}) 
 576   
 577 -    def __delfield_beginend(self): del self.__field_beginend 
 578   
 579      beginend=property(__getfield_beginend, __setfield_beginend, __delfield_beginend, None) 
 580   
 581 -    def iscontainer(self): 
 582          return True 
 583   
 584 -    def containerelements(self): 
 585          yield ('command', self.__field_command, None) 
 586          yield ('beginend', self.__field_beginend, None) 
 587   
 588   
 589   
 590   
 591 -class samheader(BaseProtogenClass): 
 592      __fields=['readwrite', 'attribute'] 
 593   
 594 -    def __init__(self, *args, **kwargs): 
 595          dict={} 
 596          # User specified arguments in the packet description 
 597          dict.update({'readwrite': 0x26}) 
 598          # What was supplied to this function 
 599          dict.update(kwargs) 
 600          # Parent constructor 
 601          super(samheader,self).__init__(**dict) 
 602          if self.__class__ is samheader: 
 603              self._update(args,dict) 
 604   
 605   
 606 -    def getfields(self): 
 607          return self.__fields 
 608   
 609   
 610 -    def _update(self, args, kwargs): 
 611          super(samheader,self)._update(args,kwargs) 
 612          keys=kwargs.keys() 
 613          for key in keys: 
 614              if key in self.__fields: 
 615                  setattr(self, key, kwargs[key]) 
 616                  del kwargs[key] 
 617          # Were any unrecognized kwargs passed in? 
 618          if __debug__: 
 619              self._complainaboutunusedargs(samheader,kwargs) 
 620          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 621          # Make all P fields that haven't already been constructed 
 622   
 623   
 624 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 625          'Writes this packet to the supplied buffer' 
 626          self._bufferstartoffset=buf.getcurrentoffset() 
 627          self.__field_readwrite.writetobuffer(buf) 
 628          self.__field_attribute.writetobuffer(buf) 
 629          self._bufferendoffset=buf.getcurrentoffset() 
 630          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 631   
 632   
 633 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 634          'Reads this packet from the supplied buffer' 
 635          self._bufferstartoffset=buf.getcurrentoffset() 
 636          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 637          self.__field_readwrite=UINT(**{'sizeinbytes': 1}) 
 638          self.__field_readwrite.readfrombuffer(buf) 
 639          self.__field_attribute=UINT(**{'sizeinbytes': 2}) 
 640          self.__field_attribute.readfrombuffer(buf) 
 641          self._bufferendoffset=buf.getcurrentoffset() 
 642   
 643   
 644 -    def __getfield_readwrite(self): 
 645          return self.__field_readwrite.getvalue() 
 646   
 647 -    def __setfield_readwrite(self, value): 
 648          if isinstance(value,UINT): 
 649              self.__field_readwrite=value 
 650          else: 
 651              self.__field_readwrite=UINT(value,**{'sizeinbytes': 1}) 
 652   
 653 -    def __delfield_readwrite(self): del self.__field_readwrite 
 654   
 655      readwrite=property(__getfield_readwrite, __setfield_readwrite, __delfield_readwrite, None) 
 656   
 657 -    def __getfield_attribute(self): 
 658          return self.__field_attribute.getvalue() 
 659   
 660 -    def __setfield_attribute(self, value): 
 661          if isinstance(value,UINT): 
 662              self.__field_attribute=value 
 663          else: 
 664              self.__field_attribute=UINT(value,**{'sizeinbytes': 2}) 
 665   
 666 -    def __delfield_attribute(self): del self.__field_attribute 
 667   
 668      attribute=property(__getfield_attribute, __setfield_attribute, __delfield_attribute, None) 
 669   
 670 -    def iscontainer(self): 
 671          return True 
 672   
 673 -    def containerelements(self): 
 674          yield ('readwrite', self.__field_readwrite, None) 
 675          yield ('attribute', self.__field_attribute, None) 
 676   
 677   
 678   
 679   
 680 -class phonebooknamerequest(BaseProtogenClass): 
 681      __fields=['header', 'slot', 'pad'] 
 682   
 683 -    def __init__(self, *args, **kwargs): 
 684          dict={} 
 685          # What was supplied to this function 
 686          dict.update(kwargs) 
 687          # Parent constructor 
 688          super(phonebooknamerequest,self).__init__(**dict) 
 689          if self.__class__ is phonebooknamerequest: 
 690              self._update(args,dict) 
 691   
 692   
 693 -    def getfields(self): 
 694          return self.__fields 
 695   
 696   
 697 -    def _update(self, args, kwargs): 
 698          super(phonebooknamerequest,self)._update(args,kwargs) 
 699          keys=kwargs.keys() 
 700          for key in keys: 
 701              if key in self.__fields: 
 702                  setattr(self, key, kwargs[key]) 
 703                  del kwargs[key] 
 704          # Were any unrecognized kwargs passed in? 
 705          if __debug__: 
 706              self._complainaboutunusedargs(phonebooknamerequest,kwargs) 
 707          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 708          # Make all P fields that haven't already been constructed 
 709   
 710   
 711 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 712          'Writes this packet to the supplied buffer' 
 713          self._bufferstartoffset=buf.getcurrentoffset() 
 714          try: self.__field_header 
 715          except: 
 716              self.__field_header=samheader(**{'attribute': 0x026B}) 
 717          self.__field_header.writetobuffer(buf) 
 718          self.__field_slot.writetobuffer(buf) 
 719          try: self.__field_pad 
 720          except: 
 721              self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 
 722          self.__field_pad.writetobuffer(buf) 
 723          self._bufferendoffset=buf.getcurrentoffset() 
 724          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 725   
 726   
 727 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 728          'Reads this packet from the supplied buffer' 
 729          self._bufferstartoffset=buf.getcurrentoffset() 
 730          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 731          self.__field_header=samheader(**{'attribute': 0x026B}) 
 732          self.__field_header.readfrombuffer(buf) 
 733          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
 734          self.__field_slot.readfrombuffer(buf) 
 735          self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 
 736          self.__field_pad.readfrombuffer(buf) 
 737          self._bufferendoffset=buf.getcurrentoffset() 
 738   
 739   
 740 -    def __getfield_header(self): 
 741          try: self.__field_header 
 742          except: 
 743              self.__field_header=samheader(**{'attribute': 0x026B}) 
 744          return self.__field_header.getvalue() 
 745   
 746 -    def __setfield_header(self, value): 
 747          if isinstance(value,samheader): 
 748              self.__field_header=value 
 749          else: 
 750              self.__field_header=samheader(value,**{'attribute': 0x026B}) 
 751   
 752 -    def __delfield_header(self): del self.__field_header 
 753   
 754      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
 755   
 756 -    def __getfield_slot(self): 
 757          return self.__field_slot.getvalue() 
 758   
 759 -    def __setfield_slot(self, value): 
 760          if isinstance(value,UINT): 
 761              self.__field_slot=value 
 762          else: 
 763              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
 764   
 765 -    def __delfield_slot(self): del self.__field_slot 
 766   
 767      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
 768   
 769 -    def __getfield_pad(self): 
 770          try: self.__field_pad 
 771          except: 
 772              self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 
 773          return self.__field_pad.getvalue() 
 774   
 775 -    def __setfield_pad(self, value): 
 776          if isinstance(value,UNKNOWN): 
 777              self.__field_pad=value 
 778          else: 
 779              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 129}) 
 780   
 781 -    def __delfield_pad(self): del self.__field_pad 
 782   
 783      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
 784   
 785 -    def iscontainer(self): 
 786          return True 
 787   
 788 -    def containerelements(self): 
 789          yield ('header', self.__field_header, None) 
 790          yield ('slot', self.__field_slot, None) 
 791          yield ('pad', self.__field_pad, None) 
 792   
 793   
 794   
 795   
 796 -class phonebookname(BaseProtogenClass): 
 797      __fields=['pad1', 'nonzeroifused', 'pspeed', 'numbers', 'pemail', 'purl', 'dunno2', 'name', 'pad2', 'pad2', 'sometimesfive'] 
 798   
 799 -    def __init__(self, *args, **kwargs): 
 800          dict={} 
 801          # What was supplied to this function 
 802          dict.update(kwargs) 
 803          # Parent constructor 
 804          super(phonebookname,self).__init__(**dict) 
 805          if self.__class__ is phonebookname: 
 806              self._update(args,dict) 
 807   
 808   
 809 -    def getfields(self): 
 810          return self.__fields 
 811   
 812   
 813 -    def _update(self, args, kwargs): 
 814          super(phonebookname,self)._update(args,kwargs) 
 815          keys=kwargs.keys() 
 816          for key in keys: 
 817              if key in self.__fields: 
 818                  setattr(self, key, kwargs[key]) 
 819                  del kwargs[key] 
 820          # Were any unrecognized kwargs passed in? 
 821          if __debug__: 
 822              self._complainaboutunusedargs(phonebookname,kwargs) 
 823          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 824          # Make all P fields that haven't already been constructed 
 825   
 826   
 827 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 828          'Writes this packet to the supplied buffer' 
 829          self._bufferstartoffset=buf.getcurrentoffset() 
 830          self.__field_pad1.writetobuffer(buf) 
 831          self.__field_nonzeroifused.writetobuffer(buf) 
 832          self.__field_pspeed.writetobuffer(buf) 
 833          self.__field_numbers.writetobuffer(buf) 
 834          self.__field_pemail.writetobuffer(buf) 
 835          self.__field_purl.writetobuffer(buf) 
 836          self.__field_dunno2.writetobuffer(buf) 
 837          self.__field_name.writetobuffer(buf) 
 838          self.__field_pad2.writetobuffer(buf) 
 839          self.__field_pad2.writetobuffer(buf) 
 840          self.__field_sometimesfive.writetobuffer(buf) 
 841          self._bufferendoffset=buf.getcurrentoffset() 
 842          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 843   
 844   
 845 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 846          'Reads this packet from the supplied buffer' 
 847          self._bufferstartoffset=buf.getcurrentoffset() 
 848          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 849          self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1}) 
 850          self.__field_pad1.readfrombuffer(buf) 
 851          self.__field_nonzeroifused=UINT(**{'sizeinbytes': 2}) 
 852          self.__field_nonzeroifused.readfrombuffer(buf) 
 853          self.__field_pspeed=UINT(**{'sizeinbytes': 2}) 
 854          self.__field_pspeed.readfrombuffer(buf) 
 855          self.__field_numbers=LIST(**{'elementclass': _gen_p_samsungsphn400_62, 'length': 7}) 
 856          self.__field_numbers.readfrombuffer(buf) 
 857          self.__field_pemail=UINT(**{'sizeinbytes': 2}) 
 858          self.__field_pemail.readfrombuffer(buf) 
 859          self.__field_purl=UINT(**{'sizeinbytes': 2}) 
 860          self.__field_purl.readfrombuffer(buf) 
 861          self.__field_dunno2=UINT(**{'sizeinbytes': 2}) 
 862          self.__field_dunno2.readfrombuffer(buf) 
 863          self.__field_name=USTRING(**{'sizeinbytes': 12}) 
 864          self.__field_name.readfrombuffer(buf) 
 865          self.__field_pad2=UNKNOWN(**{'sizeinbytes': 3}) 
 866          self.__field_pad2.readfrombuffer(buf) 
 867          self.__field_pad2=UNKNOWN(**{'sizeinbytes': 87}) 
 868          self.__field_pad2.readfrombuffer(buf) 
 869          self.__field_sometimesfive=UINT(**{'sizeinbytes': 2, 'default': 5}) 
 870          self.__field_sometimesfive.readfrombuffer(buf) 
 871          self._bufferendoffset=buf.getcurrentoffset() 
 872   
 873   
 874 -    def __getfield_pad1(self): 
 875          return self.__field_pad1.getvalue() 
 876   
 877 -    def __setfield_pad1(self, value): 
 878          if isinstance(value,UNKNOWN): 
 879              self.__field_pad1=value 
 880          else: 
 881              self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 1}) 
 882   
 883 -    def __delfield_pad1(self): del self.__field_pad1 
 884   
 885      pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None) 
 886   
 887 -    def __getfield_nonzeroifused(self): 
 888          return self.__field_nonzeroifused.getvalue() 
 889   
 890 -    def __setfield_nonzeroifused(self, value): 
 891          if isinstance(value,UINT): 
 892              self.__field_nonzeroifused=value 
 893          else: 
 894              self.__field_nonzeroifused=UINT(value,**{'sizeinbytes': 2}) 
 895   
 896 -    def __delfield_nonzeroifused(self): del self.__field_nonzeroifused 
 897   
 898      nonzeroifused=property(__getfield_nonzeroifused, __setfield_nonzeroifused, __delfield_nonzeroifused, None) 
 899   
 900 -    def __getfield_pspeed(self): 
 901          return self.__field_pspeed.getvalue() 
 902   
 903 -    def __setfield_pspeed(self, value): 
 904          if isinstance(value,UINT): 
 905              self.__field_pspeed=value 
 906          else: 
 907              self.__field_pspeed=UINT(value,**{'sizeinbytes': 2}) 
 908   
 909 -    def __delfield_pspeed(self): del self.__field_pspeed 
 910   
 911      pspeed=property(__getfield_pspeed, __setfield_pspeed, __delfield_pspeed, None) 
 912   
 913 -    def __getfield_numbers(self): 
 914          return self.__field_numbers.getvalue() 
 915   
 916 -    def __setfield_numbers(self, value): 
 917          if isinstance(value,LIST): 
 918              self.__field_numbers=value 
 919          else: 
 920              self.__field_numbers=LIST(value,**{'elementclass': _gen_p_samsungsphn400_62, 'length': 7}) 
 921   
 922 -    def __delfield_numbers(self): del self.__field_numbers 
 923   
 924      numbers=property(__getfield_numbers, __setfield_numbers, __delfield_numbers, None) 
 925   
 926 -    def __getfield_pemail(self): 
 927          return self.__field_pemail.getvalue() 
 928   
 929 -    def __setfield_pemail(self, value): 
 930          if isinstance(value,UINT): 
 931              self.__field_pemail=value 
 932          else: 
 933              self.__field_pemail=UINT(value,**{'sizeinbytes': 2}) 
 934   
 935 -    def __delfield_pemail(self): del self.__field_pemail 
 936   
 937      pemail=property(__getfield_pemail, __setfield_pemail, __delfield_pemail, None) 
 938   
 939 -    def __getfield_purl(self): 
 940          return self.__field_purl.getvalue() 
 941   
 942 -    def __setfield_purl(self, value): 
 943          if isinstance(value,UINT): 
 944              self.__field_purl=value 
 945          else: 
 946              self.__field_purl=UINT(value,**{'sizeinbytes': 2}) 
 947   
 948 -    def __delfield_purl(self): del self.__field_purl 
 949   
 950      purl=property(__getfield_purl, __setfield_purl, __delfield_purl, None) 
 951   
 952 -    def __getfield_dunno2(self): 
 953          return self.__field_dunno2.getvalue() 
 954   
 955 -    def __setfield_dunno2(self, value): 
 956          if isinstance(value,UINT): 
 957              self.__field_dunno2=value 
 958          else: 
 959              self.__field_dunno2=UINT(value,**{'sizeinbytes': 2}) 
 960   
 961 -    def __delfield_dunno2(self): del self.__field_dunno2 
 962   
 963      dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None) 
 964   
 965 -    def __getfield_name(self): 
 966          return self.__field_name.getvalue() 
 967   
 968 -    def __setfield_name(self, value): 
 969          if isinstance(value,USTRING): 
 970              self.__field_name=value 
 971          else: 
 972              self.__field_name=USTRING(value,**{'sizeinbytes': 12}) 
 973   
 974 -    def __delfield_name(self): del self.__field_name 
 975   
 976      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
 977   
 978 -    def __getfield_pad2(self): 
 979          return self.__field_pad2.getvalue() 
 980   
 981 -    def __setfield_pad2(self, value): 
 982          if isinstance(value,UNKNOWN): 
 983              self.__field_pad2=value 
 984          else: 
 985              self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 3}) 
 986   
 987 -    def __delfield_pad2(self): del self.__field_pad2 
 988   
 989      pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None) 
 990   
 991 -    def __getfield_pad2(self): 
 992          return self.__field_pad2.getvalue() 
 993   
 994 -    def __setfield_pad2(self, value): 
 995          if isinstance(value,UNKNOWN): 
 996              self.__field_pad2=value 
 997          else: 
 998              self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 87}) 
 999   
1000 -    def __delfield_pad2(self): del self.__field_pad2 
1001   
1002      pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None) 
1003   
1004 -    def __getfield_sometimesfive(self): 
1005          return self.__field_sometimesfive.getvalue() 
1006   
1007 -    def __setfield_sometimesfive(self, value): 
1008          if isinstance(value,UINT): 
1009              self.__field_sometimesfive=value 
1010          else: 
1011              self.__field_sometimesfive=UINT(value,**{'sizeinbytes': 2, 'default': 5}) 
1012   
1013 -    def __delfield_sometimesfive(self): del self.__field_sometimesfive 
1014   
1015      sometimesfive=property(__getfield_sometimesfive, __setfield_sometimesfive, __delfield_sometimesfive, None) 
1016   
1017 -    def iscontainer(self): 
1018          return True 
1019   
1020 -    def containerelements(self): 
1021          yield ('pad1', self.__field_pad1, None) 
1022          yield ('nonzeroifused', self.__field_nonzeroifused, None) 
1023          yield ('pspeed', self.__field_pspeed, None) 
1024          yield ('numbers', self.__field_numbers, None) 
1025          yield ('pemail', self.__field_pemail, None) 
1026          yield ('purl', self.__field_purl, None) 
1027          yield ('dunno2', self.__field_dunno2, None) 
1028          yield ('name', self.__field_name, None) 
1029          yield ('pad2', self.__field_pad2, None) 
1030          yield ('pad2', self.__field_pad2, None) 
1031          yield ('sometimesfive', self.__field_sometimesfive, None) 
1032   
1033   
1034   
1035   
1036 -class _gen_p_samsungsphn400_62(BaseProtogenClass): 
1037      'Anonymous inner class' 
1038      __fields=['pnumber'] 
1039   
1040 -    def __init__(self, *args, **kwargs): 
1041          dict={} 
1042          # What was supplied to this function 
1043          dict.update(kwargs) 
1044          # Parent constructor 
1045          super(_gen_p_samsungsphn400_62,self).__init__(**dict) 
1046          if self.__class__ is _gen_p_samsungsphn400_62: 
1047              self._update(args,dict) 
1048   
1049   
1050 -    def getfields(self): 
1051          return self.__fields 
1052   
1053   
1054 -    def _update(self, args, kwargs): 
1055          super(_gen_p_samsungsphn400_62,self)._update(args,kwargs) 
1056          keys=kwargs.keys() 
1057          for key in keys: 
1058              if key in self.__fields: 
1059                  setattr(self, key, kwargs[key]) 
1060                  del kwargs[key] 
1061          # Were any unrecognized kwargs passed in? 
1062          if __debug__: 
1063              self._complainaboutunusedargs(_gen_p_samsungsphn400_62,kwargs) 
1064          if len(args): 
1065              dict2={'sizeinbytes': 2} 
1066              dict2.update(kwargs) 
1067              kwargs=dict2 
1068              self.__field_pnumber=UINT(*args,**dict2) 
1069          # Make all P fields that haven't already been constructed 
1070   
1071   
1072 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1073          'Writes this packet to the supplied buffer' 
1074          self._bufferstartoffset=buf.getcurrentoffset() 
1075          self.__field_pnumber.writetobuffer(buf) 
1076          self._bufferendoffset=buf.getcurrentoffset() 
1077          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1078   
1079   
1080 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1081          'Reads this packet from the supplied buffer' 
1082          self._bufferstartoffset=buf.getcurrentoffset() 
1083          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1084          self.__field_pnumber=UINT(**{'sizeinbytes': 2}) 
1085          self.__field_pnumber.readfrombuffer(buf) 
1086          self._bufferendoffset=buf.getcurrentoffset() 
1087   
1088   
1089 -    def __getfield_pnumber(self): 
1090          return self.__field_pnumber.getvalue() 
1091   
1092 -    def __setfield_pnumber(self, value): 
1093          if isinstance(value,UINT): 
1094              self.__field_pnumber=value 
1095          else: 
1096              self.__field_pnumber=UINT(value,**{'sizeinbytes': 2}) 
1097   
1098 -    def __delfield_pnumber(self): del self.__field_pnumber 
1099   
1100      pnumber=property(__getfield_pnumber, __setfield_pnumber, __delfield_pnumber, None) 
1101   
1102 -    def iscontainer(self): 
1103          return True 
1104   
1105 -    def containerelements(self): 
1106          yield ('pnumber', self.__field_pnumber, None) 
1107   
1108   
1109   
1110   
1111 -class phonebooknameresponse(BaseProtogenClass): 
1112      __fields=['header', 'slot', 'entry', 'pad'] 
1113   
1114 -    def __init__(self, *args, **kwargs): 
1115          dict={} 
1116          # What was supplied to this function 
1117          dict.update(kwargs) 
1118          # Parent constructor 
1119          super(phonebooknameresponse,self).__init__(**dict) 
1120          if self.__class__ is phonebooknameresponse: 
1121              self._update(args,dict) 
1122   
1123   
1124 -    def getfields(self): 
1125          return self.__fields 
1126   
1127   
1128 -    def _update(self, args, kwargs): 
1129          super(phonebooknameresponse,self)._update(args,kwargs) 
1130          keys=kwargs.keys() 
1131          for key in keys: 
1132              if key in self.__fields: 
1133                  setattr(self, key, kwargs[key]) 
1134                  del kwargs[key] 
1135          # Were any unrecognized kwargs passed in? 
1136          if __debug__: 
1137              self._complainaboutunusedargs(phonebooknameresponse,kwargs) 
1138          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1139          # Make all P fields that haven't already been constructed 
1140   
1141   
1142 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1143          'Writes this packet to the supplied buffer' 
1144          self._bufferstartoffset=buf.getcurrentoffset() 
1145          self.__field_header.writetobuffer(buf) 
1146          self.__field_slot.writetobuffer(buf) 
1147          self.__field_entry.writetobuffer(buf) 
1148          self.__field_pad.writetobuffer(buf) 
1149          self._bufferendoffset=buf.getcurrentoffset() 
1150          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1151   
1152   
1153 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1154          'Reads this packet from the supplied buffer' 
1155          self._bufferstartoffset=buf.getcurrentoffset() 
1156          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1157          self.__field_header=samheader() 
1158          self.__field_header.readfrombuffer(buf) 
1159          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
1160          self.__field_slot.readfrombuffer(buf) 
1161          self.__field_entry=phonebookname() 
1162          self.__field_entry.readfrombuffer(buf) 
1163          self.__field_pad=UNKNOWN() 
1164          self.__field_pad.readfrombuffer(buf) 
1165          self._bufferendoffset=buf.getcurrentoffset() 
1166   
1167   
1168 -    def __getfield_header(self): 
1169          return self.__field_header.getvalue() 
1170   
1171 -    def __setfield_header(self, value): 
1172          if isinstance(value,samheader): 
1173              self.__field_header=value 
1174          else: 
1175              self.__field_header=samheader(value,) 
1176   
1177 -    def __delfield_header(self): del self.__field_header 
1178   
1179      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
1180   
1181 -    def __getfield_slot(self): 
1182          return self.__field_slot.getvalue() 
1183   
1184 -    def __setfield_slot(self, value): 
1185          if isinstance(value,UINT): 
1186              self.__field_slot=value 
1187          else: 
1188              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
1189   
1190 -    def __delfield_slot(self): del self.__field_slot 
1191   
1192      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
1193   
1194 -    def __getfield_entry(self): 
1195          return self.__field_entry.getvalue() 
1196   
1197 -    def __setfield_entry(self, value): 
1198          if isinstance(value,phonebookname): 
1199              self.__field_entry=value 
1200          else: 
1201              self.__field_entry=phonebookname(value,) 
1202   
1203 -    def __delfield_entry(self): del self.__field_entry 
1204   
1205      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
1206   
1207 -    def __getfield_pad(self): 
1208          return self.__field_pad.getvalue() 
1209   
1210 -    def __setfield_pad(self, value): 
1211          if isinstance(value,UNKNOWN): 
1212              self.__field_pad=value 
1213          else: 
1214              self.__field_pad=UNKNOWN(value,) 
1215   
1216 -    def __delfield_pad(self): del self.__field_pad 
1217   
1218      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
1219   
1220 -    def iscontainer(self): 
1221          return True 
1222   
1223 -    def containerelements(self): 
1224          yield ('header', self.__field_header, None) 
1225          yield ('slot', self.__field_slot, None) 
1226          yield ('entry', self.__field_entry, None) 
1227          yield ('pad', self.__field_pad, None) 
1228   
1229   
1230   
1231   
1232 -class phonebooknumbersrequest(BaseProtogenClass): 
1233      __fields=['header', 'slot', 'pad'] 
1234   
1235 -    def __init__(self, *args, **kwargs): 
1236          dict={} 
1237          # What was supplied to this function 
1238          dict.update(kwargs) 
1239          # Parent constructor 
1240          super(phonebooknumbersrequest,self).__init__(**dict) 
1241          if self.__class__ is phonebooknumbersrequest: 
1242              self._update(args,dict) 
1243   
1244   
1245 -    def getfields(self): 
1246          return self.__fields 
1247   
1248   
1249 -    def _update(self, args, kwargs): 
1250          super(phonebooknumbersrequest,self)._update(args,kwargs) 
1251          keys=kwargs.keys() 
1252          for key in keys: 
1253              if key in self.__fields: 
1254                  setattr(self, key, kwargs[key]) 
1255                  del kwargs[key] 
1256          # Were any unrecognized kwargs passed in? 
1257          if __debug__: 
1258              self._complainaboutunusedargs(phonebooknumbersrequest,kwargs) 
1259          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1260          # Make all P fields that haven't already been constructed 
1261   
1262   
1263 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1264          'Writes this packet to the supplied buffer' 
1265          self._bufferstartoffset=buf.getcurrentoffset() 
1266          try: self.__field_header 
1267          except: 
1268              self.__field_header=samheader(**{'attribute': 0x026A}) 
1269          self.__field_header.writetobuffer(buf) 
1270          self.__field_slot.writetobuffer(buf) 
1271          try: self.__field_pad 
1272          except: 
1273              self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 
1274          self.__field_pad.writetobuffer(buf) 
1275          self._bufferendoffset=buf.getcurrentoffset() 
1276          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1277   
1278   
1279 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1280          'Reads this packet from the supplied buffer' 
1281          self._bufferstartoffset=buf.getcurrentoffset() 
1282          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1283          self.__field_header=samheader(**{'attribute': 0x026A}) 
1284          self.__field_header.readfrombuffer(buf) 
1285          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
1286          self.__field_slot.readfrombuffer(buf) 
1287          self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 
1288          self.__field_pad.readfrombuffer(buf) 
1289          self._bufferendoffset=buf.getcurrentoffset() 
1290   
1291   
1292 -    def __getfield_header(self): 
1293          try: self.__field_header 
1294          except: 
1295              self.__field_header=samheader(**{'attribute': 0x026A}) 
1296          return self.__field_header.getvalue() 
1297   
1298 -    def __setfield_header(self, value): 
1299          if isinstance(value,samheader): 
1300              self.__field_header=value 
1301          else: 
1302              self.__field_header=samheader(value,**{'attribute': 0x026A}) 
1303   
1304 -    def __delfield_header(self): del self.__field_header 
1305   
1306      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
1307   
1308 -    def __getfield_slot(self): 
1309          return self.__field_slot.getvalue() 
1310   
1311 -    def __setfield_slot(self, value): 
1312          if isinstance(value,UINT): 
1313              self.__field_slot=value 
1314          else: 
1315              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
1316   
1317 -    def __delfield_slot(self): del self.__field_slot 
1318   
1319      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
1320   
1321 -    def __getfield_pad(self): 
1322          try: self.__field_pad 
1323          except: 
1324              self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 
1325          return self.__field_pad.getvalue() 
1326   
1327 -    def __setfield_pad(self, value): 
1328          if isinstance(value,UNKNOWN): 
1329              self.__field_pad=value 
1330          else: 
1331              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 129}) 
1332   
1333 -    def __delfield_pad(self): del self.__field_pad 
1334   
1335      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
1336   
1337 -    def iscontainer(self): 
1338          return True 
1339   
1340 -    def containerelements(self): 
1341          yield ('header', self.__field_header, None) 
1342          yield ('slot', self.__field_slot, None) 
1343          yield ('pad', self.__field_pad, None) 
1344   
1345   
1346   
1347   
1348 -class phonebooknumbers(BaseProtogenClass): 
1349      __fields=['pad', 'number_len', 'number'] 
1350   
1351 -    def __init__(self, *args, **kwargs): 
1352          dict={} 
1353          # What was supplied to this function 
1354          dict.update(kwargs) 
1355          # Parent constructor 
1356          super(phonebooknumbers,self).__init__(**dict) 
1357          if self.__class__ is phonebooknumbers: 
1358              self._update(args,dict) 
1359   
1360   
1361 -    def getfields(self): 
1362          return self.__fields 
1363   
1364   
1365 -    def _update(self, args, kwargs): 
1366          super(phonebooknumbers,self)._update(args,kwargs) 
1367          keys=kwargs.keys() 
1368          for key in keys: 
1369              if key in self.__fields: 
1370                  setattr(self, key, kwargs[key]) 
1371                  del kwargs[key] 
1372          # Were any unrecognized kwargs passed in? 
1373          if __debug__: 
1374              self._complainaboutunusedargs(phonebooknumbers,kwargs) 
1375          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1376          # Make all P fields that haven't already been constructed 
1377   
1378   
1379 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1380          'Writes this packet to the supplied buffer' 
1381          self._bufferstartoffset=buf.getcurrentoffset() 
1382          self.__field_pad.writetobuffer(buf) 
1383          self.__field_number_len.writetobuffer(buf) 
1384          self.__field_number.writetobuffer(buf) 
1385          self._bufferendoffset=buf.getcurrentoffset() 
1386          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1387   
1388   
1389 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1390          'Reads this packet from the supplied buffer' 
1391          self._bufferstartoffset=buf.getcurrentoffset() 
1392          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1393          self.__field_pad=UNKNOWN(**{'sizeinbytes': 2}) 
1394          self.__field_pad.readfrombuffer(buf) 
1395          self.__field_number_len=UINT(**{'sizeinbytes': 1}) 
1396          self.__field_number_len.readfrombuffer(buf) 
1397          self.__field_number=USTRING(**{'sizeinbytes': 32, 'raiseonunterminatedread': False}) 
1398          self.__field_number.readfrombuffer(buf) 
1399          self._bufferendoffset=buf.getcurrentoffset() 
1400   
1401   
1402 -    def __getfield_pad(self): 
1403          return self.__field_pad.getvalue() 
1404   
1405 -    def __setfield_pad(self, value): 
1406          if isinstance(value,UNKNOWN): 
1407              self.__field_pad=value 
1408          else: 
1409              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 2}) 
1410   
1411 -    def __delfield_pad(self): del self.__field_pad 
1412   
1413      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
1414   
1415 -    def __getfield_number_len(self): 
1416          return self.__field_number_len.getvalue() 
1417   
1418 -    def __setfield_number_len(self, value): 
1419          if isinstance(value,UINT): 
1420              self.__field_number_len=value 
1421          else: 
1422              self.__field_number_len=UINT(value,**{'sizeinbytes': 1}) 
1423   
1424 -    def __delfield_number_len(self): del self.__field_number_len 
1425   
1426      number_len=property(__getfield_number_len, __setfield_number_len, __delfield_number_len, None) 
1427   
1428 -    def __getfield_number(self): 
1429          return self.__field_number.getvalue() 
1430   
1431 -    def __setfield_number(self, value): 
1432          if isinstance(value,USTRING): 
1433              self.__field_number=value 
1434          else: 
1435              self.__field_number=USTRING(value,**{'sizeinbytes': 32, 'raiseonunterminatedread': False}) 
1436   
1437 -    def __delfield_number(self): del self.__field_number 
1438   
1439      number=property(__getfield_number, __setfield_number, __delfield_number, None) 
1440   
1441 -    def iscontainer(self): 
1442          return True 
1443   
1444 -    def containerelements(self): 
1445          yield ('pad', self.__field_pad, None) 
1446          yield ('number_len', self.__field_number_len, None) 
1447          yield ('number', self.__field_number, None) 
1448   
1449   
1450   
1451   
1452 -class phonebooknumbersresponse(BaseProtogenClass): 
1453      __fields=['header', 'slot', 'entry', 'pad'] 
1454   
1455 -    def __init__(self, *args, **kwargs): 
1456          dict={} 
1457          # What was supplied to this function 
1458          dict.update(kwargs) 
1459          # Parent constructor 
1460          super(phonebooknumbersresponse,self).__init__(**dict) 
1461          if self.__class__ is phonebooknumbersresponse: 
1462              self._update(args,dict) 
1463   
1464   
1465 -    def getfields(self): 
1466          return self.__fields 
1467   
1468   
1469 -    def _update(self, args, kwargs): 
1470          super(phonebooknumbersresponse,self)._update(args,kwargs) 
1471          keys=kwargs.keys() 
1472          for key in keys: 
1473              if key in self.__fields: 
1474                  setattr(self, key, kwargs[key]) 
1475                  del kwargs[key] 
1476          # Were any unrecognized kwargs passed in? 
1477          if __debug__: 
1478              self._complainaboutunusedargs(phonebooknumbersresponse,kwargs) 
1479          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1480          # Make all P fields that haven't already been constructed 
1481   
1482   
1483 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1484          'Writes this packet to the supplied buffer' 
1485          self._bufferstartoffset=buf.getcurrentoffset() 
1486          self.__field_header.writetobuffer(buf) 
1487          self.__field_slot.writetobuffer(buf) 
1488          self.__field_entry.writetobuffer(buf) 
1489          self.__field_pad.writetobuffer(buf) 
1490          self._bufferendoffset=buf.getcurrentoffset() 
1491          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1492   
1493   
1494 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1495          'Reads this packet from the supplied buffer' 
1496          self._bufferstartoffset=buf.getcurrentoffset() 
1497          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1498          self.__field_header=samheader() 
1499          self.__field_header.readfrombuffer(buf) 
1500          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
1501          self.__field_slot.readfrombuffer(buf) 
1502          self.__field_entry=phonebooknumbers() 
1503          self.__field_entry.readfrombuffer(buf) 
1504          self.__field_pad=UNKNOWN() 
1505          self.__field_pad.readfrombuffer(buf) 
1506          self._bufferendoffset=buf.getcurrentoffset() 
1507   
1508   
1509 -    def __getfield_header(self): 
1510          return self.__field_header.getvalue() 
1511   
1512 -    def __setfield_header(self, value): 
1513          if isinstance(value,samheader): 
1514              self.__field_header=value 
1515          else: 
1516              self.__field_header=samheader(value,) 
1517   
1518 -    def __delfield_header(self): del self.__field_header 
1519   
1520      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
1521   
1522 -    def __getfield_slot(self): 
1523          return self.__field_slot.getvalue() 
1524   
1525 -    def __setfield_slot(self, value): 
1526          if isinstance(value,UINT): 
1527              self.__field_slot=value 
1528          else: 
1529              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
1530   
1531 -    def __delfield_slot(self): del self.__field_slot 
1532   
1533      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
1534   
1535 -    def __getfield_entry(self): 
1536          return self.__field_entry.getvalue() 
1537   
1538 -    def __setfield_entry(self, value): 
1539          if isinstance(value,phonebooknumbers): 
1540              self.__field_entry=value 
1541          else: 
1542              self.__field_entry=phonebooknumbers(value,) 
1543   
1544 -    def __delfield_entry(self): del self.__field_entry 
1545   
1546      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
1547   
1548 -    def __getfield_pad(self): 
1549          return self.__field_pad.getvalue() 
1550   
1551 -    def __setfield_pad(self, value): 
1552          if isinstance(value,UNKNOWN): 
1553              self.__field_pad=value 
1554          else: 
1555              self.__field_pad=UNKNOWN(value,) 
1556   
1557 -    def __delfield_pad(self): del self.__field_pad 
1558   
1559      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
1560   
1561 -    def iscontainer(self): 
1562          return True 
1563   
1564 -    def containerelements(self): 
1565          yield ('header', self.__field_header, None) 
1566          yield ('slot', self.__field_slot, None) 
1567          yield ('entry', self.__field_entry, None) 
1568          yield ('pad', self.__field_pad, None) 
1569   
1570   
1571   
1572   
1573 -class attributerequest(BaseProtogenClass): 
1574      __fields=['command', 'attribute', 'pad'] 
1575   
1576 -    def __init__(self, *args, **kwargs): 
1577          dict={} 
1578          # What was supplied to this function 
1579          dict.update(kwargs) 
1580          # Parent constructor 
1581          super(attributerequest,self).__init__(**dict) 
1582          if self.__class__ is attributerequest: 
1583              self._update(args,dict) 
1584   
1585   
1586 -    def getfields(self): 
1587          return self.__fields 
1588   
1589   
1590 -    def _update(self, args, kwargs): 
1591          super(attributerequest,self)._update(args,kwargs) 
1592          keys=kwargs.keys() 
1593          for key in keys: 
1594              if key in self.__fields: 
1595                  setattr(self, key, kwargs[key]) 
1596                  del kwargs[key] 
1597          # Were any unrecognized kwargs passed in? 
1598          if __debug__: 
1599              self._complainaboutunusedargs(attributerequest,kwargs) 
1600          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1601          # Make all P fields that haven't already been constructed 
1602   
1603   
1604 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1605          'Writes this packet to the supplied buffer' 
1606          self._bufferstartoffset=buf.getcurrentoffset() 
1607          try: self.__field_command 
1608          except: 
1609              self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x26}) 
1610          self.__field_command.writetobuffer(buf) 
1611          self.__field_attribute.writetobuffer(buf) 
1612          try: self.__field_pad 
1613          except: 
1614              self.__field_pad=UNKNOWN(**{'sizeinbytes': 259}) 
1615          self.__field_pad.writetobuffer(buf) 
1616          self._bufferendoffset=buf.getcurrentoffset() 
1617          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1618   
1619   
1620 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1621          'Reads this packet from the supplied buffer' 
1622          self._bufferstartoffset=buf.getcurrentoffset() 
1623          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1624          self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x26}) 
1625          self.__field_command.readfrombuffer(buf) 
1626          self.__field_attribute=UINT(**{'sizeinbytes': 2}) 
1627          self.__field_attribute.readfrombuffer(buf) 
1628          self.__field_pad=UNKNOWN(**{'sizeinbytes': 259}) 
1629          self.__field_pad.readfrombuffer(buf) 
1630          self._bufferendoffset=buf.getcurrentoffset() 
1631   
1632   
1633 -    def __getfield_command(self): 
1634          try: self.__field_command 
1635          except: 
1636              self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x26}) 
1637          return self.__field_command.getvalue() 
1638   
1639 -    def __setfield_command(self, value): 
1640          if isinstance(value,UINT): 
1641              self.__field_command=value 
1642          else: 
1643              self.__field_command=UINT(value,**{'sizeinbytes': 1, 'constant': 0x26}) 
1644   
1645 -    def __delfield_command(self): del self.__field_command 
1646   
1647      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
1648   
1649 -    def __getfield_attribute(self): 
1650          return self.__field_attribute.getvalue() 
1651   
1652 -    def __setfield_attribute(self, value): 
1653          if isinstance(value,UINT): 
1654              self.__field_attribute=value 
1655          else: 
1656              self.__field_attribute=UINT(value,**{'sizeinbytes': 2}) 
1657   
1658 -    def __delfield_attribute(self): del self.__field_attribute 
1659   
1660      attribute=property(__getfield_attribute, __setfield_attribute, __delfield_attribute, None) 
1661   
1662 -    def __getfield_pad(self): 
1663          try: self.__field_pad 
1664          except: 
1665              self.__field_pad=UNKNOWN(**{'sizeinbytes': 259}) 
1666          return self.__field_pad.getvalue() 
1667   
1668 -    def __setfield_pad(self, value): 
1669          if isinstance(value,UNKNOWN): 
1670              self.__field_pad=value 
1671          else: 
1672              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 259}) 
1673   
1674 -    def __delfield_pad(self): del self.__field_pad 
1675   
1676      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
1677   
1678 -    def iscontainer(self): 
1679          return True 
1680   
1681 -    def containerelements(self): 
1682          yield ('command', self.__field_command, None) 
1683          yield ('attribute', self.__field_attribute, None) 
1684          yield ('pad', self.__field_pad, None) 
1685