Trees       Indices       Help   
bitpim
Package phones :: Module p_audiovoxcdm8900
[hide private]
[frames] | no frames]

Source Code for Module phones.p_audiovoxcdm8900

   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  _NUMGROUPS=7 
  13  _ALLGROUP=0 
  14  _MAXGROUPLEN=16 
  15  _MAXPHONENUMBERLEN=32 
  16  _MAXNAMELEN=16 
  17  _MAXEMAILLEN=48 
  18  _MAXMEMOLEN=48 

  19 -class readpbslotsrequest(BaseProtogenClass): 

  20      "Get a list of which slots are used" 
  21      __fields=['cmd'] 
  22   

  23 -    def __init__(self, *args, **kwargs): 

  24          dict={} 
  25          # What was supplied to this function 
  26          dict.update(kwargs) 
  27          # Parent constructor 
  28          super(readpbslotsrequest,self).__init__(**dict) 
  29          if self.__class__ is readpbslotsrequest: 
  30              self._update(args,dict) 

  31   
  32   

  33 -    def getfields(self): 

  34          return self.__fields 

  35   
  36   

  37 -    def _update(self, args, kwargs): 

  38          super(readpbslotsrequest,self)._update(args,kwargs) 
  39          keys=kwargs.keys() 
  40          for key in keys: 
  41              if key in self.__fields: 
  42                  setattr(self, key, kwargs[key]) 
  43                  del kwargs[key] 
  44          # Were any unrecognized kwargs passed in? 
  45          if __debug__: 
  46              self._complainaboutunusedargs(readpbslotsrequest,kwargs) 
  47          if len(args): 
  48              dict2={'sizeinbytes': 1, 'constant': 0x85} 
  49              dict2.update(kwargs) 
  50              kwargs=dict2 
  51              self.__field_cmd=UINT(*args,**dict2) 

  52          # Make all P fields that haven't already been constructed 
  53   
  54   

  55 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 

  56          'Writes this packet to the supplied buffer' 
  57          self._bufferstartoffset=buf.getcurrentoffset() 
  58          try: self.__field_cmd 
  59          except: 
  60              self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x85}) 
  61          self.__field_cmd.writetobuffer(buf) 
  62          self._bufferendoffset=buf.getcurrentoffset() 
  63          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 

  64   
  65   

  66 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 

  67          'Reads this packet from the supplied buffer' 
  68          self._bufferstartoffset=buf.getcurrentoffset() 
  69          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
  70          self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x85}) 
  71          self.__field_cmd.readfrombuffer(buf) 
  72          self._bufferendoffset=buf.getcurrentoffset() 

  73   
  74   

  75 -    def __getfield_cmd(self): 

  76          try: self.__field_cmd 
  77          except: 
  78              self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x85}) 
  79          return self.__field_cmd.getvalue() 

  80   

  81 -    def __setfield_cmd(self, value): 

  82          if isinstance(value,UINT): 
  83              self.__field_cmd=value 
  84          else: 
  85              self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'constant': 0x85}) 

  86   

  87 -    def __delfield_cmd(self): del self.__field_cmd 

  88   
  89      cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None) 
  90   

  91 -    def iscontainer(self): 

  92          return True 

  93   

  94 -    def containerelements(self): 

  95          yield ('cmd', self.__field_cmd, None) 

  96   
  97   
  98   
  99   

 100 -class readpbslotsresponse(BaseProtogenClass): 

 101      __fields=['cmd', 'present'] 
 102   

 103 -    def __init__(self, *args, **kwargs): 

 104          dict={} 
 105          # What was supplied to this function 
 106          dict.update(kwargs) 
 107          # Parent constructor 
 108          super(readpbslotsresponse,self).__init__(**dict) 
 109          if self.__class__ is readpbslotsresponse: 
 110              self._update(args,dict) 

 111   
 112   

 113 -    def getfields(self): 

 114          return self.__fields 

 115   
 116   

 117 -    def _update(self, args, kwargs): 

 118          super(readpbslotsresponse,self)._update(args,kwargs) 
 119          keys=kwargs.keys() 
 120          for key in keys: 
 121              if key in self.__fields: 
 122                  setattr(self, key, kwargs[key]) 
 123                  del kwargs[key] 
 124          # Were any unrecognized kwargs passed in? 
 125          if __debug__: 
 126              self._complainaboutunusedargs(readpbslotsresponse,kwargs) 
 127          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 

 128          # Make all P fields that haven't already been constructed 
 129   
 130   

 131 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 

 132          'Writes this packet to the supplied buffer' 
 133          self._bufferstartoffset=buf.getcurrentoffset() 
 134          self.__field_cmd.writetobuffer(buf) 
 135          self.__field_present.writetobuffer(buf) 
 136          self._bufferendoffset=buf.getcurrentoffset() 
 137          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 

 138   
 139   

 140 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 

 141          'Reads this packet from the supplied buffer' 
 142          self._bufferstartoffset=buf.getcurrentoffset() 
 143          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 144          self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x85}) 
 145          self.__field_cmd.readfrombuffer(buf) 
 146          self.__field_present=DATA() 
 147          self.__field_present.readfrombuffer(buf) 
 148          self._bufferendoffset=buf.getcurrentoffset() 

 149   
 150   

 151 -    def __getfield_cmd(self): 

 152          return self.__field_cmd.getvalue() 

 153   

 154 -    def __setfield_cmd(self, value): 

 155          if isinstance(value,UINT): 
 156              self.__field_cmd=value 
 157          else: 
 158              self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'constant': 0x85}) 

 159   

 160 -    def __delfield_cmd(self): del self.__field_cmd 

 161   
 162      cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None) 
 163   

 164 -    def __getfield_present(self): 

 165          return self.__field_present.getvalue() 

 166   

 167 -    def __setfield_present(self, value): 

 168          if isinstance(value,DATA): 
 169              self.__field_present=value 
 170          else: 
 171              self.__field_present=DATA(value,) 

 172   

 173 -    def __delfield_present(self): del self.__field_present 

 174   
 175      present=property(__getfield_present, __setfield_present, __delfield_present, "a non-zero value indicates a slot is present") 
 176   

 177 -    def iscontainer(self): 

 178          return True 

 179   

 180 -    def containerelements(self): 

 181          yield ('cmd', self.__field_cmd, None) 
 182          yield ('present', self.__field_present, "a non-zero value indicates a slot is present") 

 183   
 184   
 185   
 186   

 187 -class writepbslotsrequest(BaseProtogenClass): 

 188      __fields=['cmd', 'present'] 
 189   

 190 -    def __init__(self, *args, **kwargs): 

 191          dict={} 
 192          # What was supplied to this function 
 193          dict.update(kwargs) 
 194          # Parent constructor 
 195          super(writepbslotsrequest,self).__init__(**dict) 
 196          if self.__class__ is writepbslotsrequest: 
 197              self._update(args,dict) 

 198   
 199   

 200 -    def getfields(self): 

 201          return self.__fields 

 202   
 203   

 204 -    def _update(self, args, kwargs): 

 205          super(writepbslotsrequest,self)._update(args,kwargs) 
 206          keys=kwargs.keys() 
 207          for key in keys: 
 208              if key in self.__fields: 
 209                  setattr(self, key, kwargs[key]) 
 210                  del kwargs[key] 
 211          # Were any unrecognized kwargs passed in? 
 212          if __debug__: 
 213              self._complainaboutunusedargs(writepbslotsrequest,kwargs) 
 214          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 

 215          # Make all P fields that haven't already been constructed 
 216   
 217   

 218 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 

 219          'Writes this packet to the supplied buffer' 
 220          self._bufferstartoffset=buf.getcurrentoffset() 
 221          try: self.__field_cmd 
 222          except: 
 223              self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x84}) 
 224          self.__field_cmd.writetobuffer(buf) 
 225          self.__field_present.writetobuffer(buf) 
 226          self._bufferendoffset=buf.getcurrentoffset() 
 227          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 

 228   
 229   

 230 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 

 231          'Reads this packet from the supplied buffer' 
 232          self._bufferstartoffset=buf.getcurrentoffset() 
 233          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 234          self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x84}) 
 235          self.__field_cmd.readfrombuffer(buf) 
 236          self.__field_present=DATA() 
 237          self.__field_present.readfrombuffer(buf) 
 238          self._bufferendoffset=buf.getcurrentoffset() 

 239   
 240   

 241 -    def __getfield_cmd(self): 

 242          try: self.__field_cmd 
 243          except: 
 244              self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x84}) 
 245          return self.__field_cmd.getvalue() 

 246   

 247 -    def __setfield_cmd(self, value): 

 248          if isinstance(value,UINT): 
 249              self.__field_cmd=value 
 250          else: 
 251              self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'constant': 0x84}) 

 252   

 253 -    def __delfield_cmd(self): del self.__field_cmd 

 254   
 255      cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None) 
 256   

 257 -    def __getfield_present(self): 

 258          return self.__field_present.getvalue() 

 259   

 260 -    def __setfield_present(self, value): 

 261          if isinstance(value,DATA): 
 262              self.__field_present=value 
 263          else: 
 264              self.__field_present=DATA(value,) 

 265   

 266 -    def __delfield_present(self): del self.__field_present 

 267   
 268      present=property(__getfield_present, __setfield_present, __delfield_present, "a non-zero value indicates a slot is present") 
 269   

 270 -    def iscontainer(self): 

 271          return True 

 272   

 273 -    def containerelements(self): 

 274          yield ('cmd', self.__field_cmd, None) 
 275          yield ('present', self.__field_present, "a non-zero value indicates a slot is present") 

 276   
 277   
 278   
 279   

 280 -class writepbslotsresponse(BaseProtogenClass): 

 281      __fields=['cmd'] 
 282   

 283 -    def __init__(self, *args, **kwargs): 

 284          dict={} 
 285          # What was supplied to this function 
 286          dict.update(kwargs) 
 287          # Parent constructor 
 288          super(writepbslotsresponse,self).__init__(**dict) 
 289          if self.__class__ is writepbslotsresponse: 
 290              self._update(args,dict) 

 291   
 292   

 293 -    def getfields(self): 

 294          return self.__fields 

 295   
 296   

 297 -    def _update(self, args, kwargs): 

 298          super(writepbslotsresponse,self)._update(args,kwargs) 
 299          keys=kwargs.keys() 
 300          for key in keys: 
 301              if key in self.__fields: 
 302                  setattr(self, key, kwargs[key]) 
 303                  del kwargs[key] 
 304          # Were any unrecognized kwargs passed in? 
 305          if __debug__: 
 306              self._complainaboutunusedargs(writepbslotsresponse,kwargs) 
 307          if len(args): 
 308              dict2={'sizeinbytes': 1, 'constant': 0x84} 
 309              dict2.update(kwargs) 
 310              kwargs=dict2 
 311              self.__field_cmd=UINT(*args,**dict2) 

 312          # Make all P fields that haven't already been constructed 
 313   
 314   

 315 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 

 316          'Writes this packet to the supplied buffer' 
 317          self._bufferstartoffset=buf.getcurrentoffset() 
 318          self.__field_cmd.writetobuffer(buf) 
 319          self._bufferendoffset=buf.getcurrentoffset() 
 320          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 

 321   
 322   

 323 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 

 324          'Reads this packet from the supplied buffer' 
 325          self._bufferstartoffset=buf.getcurrentoffset() 
 326          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 327          self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x84}) 
 328          self.__field_cmd.readfrombuffer(buf) 
 329          self._bufferendoffset=buf.getcurrentoffset() 

 330   
 331   

 332 -    def __getfield_cmd(self): 

 333          return self.__field_cmd.getvalue() 

 334   

 335 -    def __setfield_cmd(self, value): 

 336          if isinstance(value,UINT): 
 337              self.__field_cmd=value 
 338          else: 
 339              self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'constant': 0x84}) 

 340   

 341 -    def __delfield_cmd(self): del self.__field_cmd 

 342   
 343      cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None) 
 344   

 345 -    def iscontainer(self): 

 346          return True 

 347   

 348 -    def containerelements(self): 

 349          yield ('cmd', self.__field_cmd, None) 

 350   
 351   
 352   
 353   

 354 -class readpbentryrequest(BaseProtogenClass): 

 355      __fields=['cmd', 'slotnumber'] 
 356   

 357 -    def __init__(self, *args, **kwargs): 

 358          dict={} 
 359          # What was supplied to this function 
 360          dict.update(kwargs) 
 361          # Parent constructor 
 362          super(readpbentryrequest,self).__init__(**dict) 
 363          if self.__class__ is readpbentryrequest: 
 364              self._update(args,dict) 

 365   
 366   

 367 -    def getfields(self): 

 368          return self.__fields 

 369   
 370   

 371 -    def _update(self, args, kwargs): 

 372          super(readpbentryrequest,self)._update(args,kwargs) 
 373          keys=kwargs.keys() 
 374          for key in keys: 
 375              if key in self.__fields: 
 376                  setattr(self, key, kwargs[key]) 
 377                  del kwargs[key] 
 378          # Were any unrecognized kwargs passed in? 
 379          if __debug__: 
 380              self._complainaboutunusedargs(readpbentryrequest,kwargs) 
 381          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 

 382          # Make all P fields that haven't already been constructed 
 383   
 384   

 385 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 

 386          'Writes this packet to the supplied buffer' 
 387          self._bufferstartoffset=buf.getcurrentoffset() 
 388          try: self.__field_cmd 
 389          except: 
 390              self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x83}) 
 391          self.__field_cmd.writetobuffer(buf) 
 392          self.__field_slotnumber.writetobuffer(buf) 
 393          self._bufferendoffset=buf.getcurrentoffset() 
 394          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 

 395   
 396   

 397 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 

 398          'Reads this packet from the supplied buffer' 
 399          self._bufferstartoffset=buf.getcurrentoffset() 
 400          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 401          self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x83}) 
 402          self.__field_cmd.readfrombuffer(buf) 
 403          self.__field_slotnumber=UINT(**{'sizeinbytes': 2}) 
 404          self.__field_slotnumber.readfrombuffer(buf) 
 405          self._bufferendoffset=buf.getcurrentoffset() 

 406   
 407   

 408 -    def __getfield_cmd(self): 

 409          try: self.__field_cmd 
 410          except: 
 411              self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x83}) 
 412          return self.__field_cmd.getvalue() 

 413   

 414 -    def __setfield_cmd(self, value): 

 415          if isinstance(value,UINT): 
 416              self.__field_cmd=value 
 417          else: 
 418              self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'constant': 0x83}) 

 419   

 420 -    def __delfield_cmd(self): del self.__field_cmd 

 421   
 422      cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None) 
 423   

 424 -    def __getfield_slotnumber(self): 

 425          return self.__field_slotnumber.getvalue() 

 426   

 427 -    def __setfield_slotnumber(self, value): 

 428          if isinstance(value,UINT): 
 429              self.__field_slotnumber=value 
 430          else: 
 431              self.__field_slotnumber=UINT(value,**{'sizeinbytes': 2}) 

 432   

 433 -    def __delfield_slotnumber(self): del self.__field_slotnumber 

 434   
 435      slotnumber=property(__getfield_slotnumber, __setfield_slotnumber, __delfield_slotnumber, None) 
 436   

 437 -    def iscontainer(self): 

 438          return True 

 439   

 440 -    def containerelements(self): 

 441          yield ('cmd', self.__field_cmd, None) 
 442          yield ('slotnumber', self.__field_slotnumber, None) 

 443   
 444   
 445   
 446   

 447 -class readpbentryresponse(BaseProtogenClass): 

 448      __fields=['cmd', 'slotnumber', 'entry'] 
 449   

 450 -    def __init__(self, *args, **kwargs): 

 451          dict={} 
 452          # What was supplied to this function 
 453          dict.update(kwargs) 
 454          # Parent constructor 
 455          super(readpbentryresponse,self).__init__(**dict) 
 456          if self.__class__ is readpbentryresponse: 
 457              self._update(args,dict) 

 458   
 459   

 460 -    def getfields(self): 

 461          return self.__fields 

 462   
 463   

 464 -    def _update(self, args, kwargs): 

 465          super(readpbentryresponse,self)._update(args,kwargs) 
 466          keys=kwargs.keys() 
 467          for key in keys: 
 468              if key in self.__fields: 
 469                  setattr(self, key, kwargs[key]) 
 470                  del kwargs[key] 
 471          # Were any unrecognized kwargs passed in? 
 472          if __debug__: 
 473              self._complainaboutunusedargs(readpbentryresponse,kwargs) 
 474          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 

 475          # Make all P fields that haven't already been constructed 
 476   
 477   

 478 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 

 479          'Writes this packet to the supplied buffer' 
 480          self._bufferstartoffset=buf.getcurrentoffset() 
 481          try: self.__field_cmd 
 482          except: 
 483              self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x83}) 
 484          self.__field_cmd.writetobuffer(buf) 
 485          self.__field_slotnumber.writetobuffer(buf) 
 486          self.__field_entry.writetobuffer(buf) 
 487          self._bufferendoffset=buf.getcurrentoffset() 
 488          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 

 489   
 490   

 491 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 

 492          'Reads this packet from the supplied buffer' 
 493          self._bufferstartoffset=buf.getcurrentoffset() 
 494          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 495          self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x83}) 
 496          self.__field_cmd.readfrombuffer(buf) 
 497          self.__field_slotnumber=UINT(**{'sizeinbytes': 2}) 
 498          self.__field_slotnumber.readfrombuffer(buf) 
 499          self.__field_entry=pbentry() 
 500          self.__field_entry.readfrombuffer(buf) 
 501          self._bufferendoffset=buf.getcurrentoffset() 

 502   
 503   

 504 -    def __getfield_cmd(self): 

 505          try: self.__field_cmd 
 506          except: 
 507              self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x83}) 
 508          return self.__field_cmd.getvalue() 

 509   

 510 -    def __setfield_cmd(self, value): 

 511          if isinstance(value,UINT): 
 512              self.__field_cmd=value 
 513          else: 
 514              self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'constant': 0x83}) 

 515   

 516 -    def __delfield_cmd(self): del self.__field_cmd 

 517   
 518      cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None) 
 519   

 520 -    def __getfield_slotnumber(self): 

 521          return self.__field_slotnumber.getvalue() 

 522   

 523 -    def __setfield_slotnumber(self, value): 

 524          if isinstance(value,UINT): 
 525              self.__field_slotnumber=value 
 526          else: 
 527              self.__field_slotnumber=UINT(value,**{'sizeinbytes': 2}) 

 528   

 529 -    def __delfield_slotnumber(self): del self.__field_slotnumber 

 530   
 531      slotnumber=property(__getfield_slotnumber, __setfield_slotnumber, __delfield_slotnumber, None) 
 532   

 533 -    def __getfield_entry(self): 

 534          return self.__field_entry.getvalue() 

 535   

 536 -    def __setfield_entry(self, value): 

 537          if isinstance(value,pbentry): 
 538              self.__field_entry=value 
 539          else: 
 540              self.__field_entry=pbentry(value,) 

 541   

 542 -    def __delfield_entry(self): del self.__field_entry 

 543   
 544      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
 545   

 546 -    def iscontainer(self): 

 547          return True 

 548   

 549 -    def containerelements(self): 

 550          yield ('cmd', self.__field_cmd, None) 
 551          yield ('slotnumber', self.__field_slotnumber, None) 
 552          yield ('entry', self.__field_entry, None) 

 553   
 554   
 555   
 556   

 557 -class writepbentryrequest(BaseProtogenClass): 

 558      __fields=['cmd', 'slotnumber', 'entry'] 
 559   

 560 -    def __init__(self, *args, **kwargs): 

 561          dict={} 
 562          # What was supplied to this function 
 563          dict.update(kwargs) 
 564          # Parent constructor 
 565          super(writepbentryrequest,self).__init__(**dict) 
 566          if self.__class__ is writepbentryrequest: 
 567              self._update(args,dict) 

 568   
 569   

 570 -    def getfields(self): 

 571          return self.__fields 

 572   
 573   

 574 -    def _update(self, args, kwargs): 

 575          super(writepbentryrequest,self)._update(args,kwargs) 
 576          keys=kwargs.keys() 
 577          for key in keys: 
 578              if key in self.__fields: 
 579                  setattr(self, key, kwargs[key]) 
 580                  del kwargs[key] 
 581          # Were any unrecognized kwargs passed in? 
 582          if __debug__: 
 583              self._complainaboutunusedargs(writepbentryrequest,kwargs) 
 584          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 

 585          # Make all P fields that haven't already been constructed 
 586   
 587   

 588 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 

 589          'Writes this packet to the supplied buffer' 
 590          self._bufferstartoffset=buf.getcurrentoffset() 
 591          try: self.__field_cmd 
 592          except: 
 593              self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x82}) 
 594          self.__field_cmd.writetobuffer(buf) 
 595          self.__field_slotnumber.writetobuffer(buf) 
 596          self.__field_entry.writetobuffer(buf) 
 597          self._bufferendoffset=buf.getcurrentoffset() 
 598          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 

 599   
 600   

 601 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 

 602          'Reads this packet from the supplied buffer' 
 603          self._bufferstartoffset=buf.getcurrentoffset() 
 604          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 605          self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x82}) 
 606          self.__field_cmd.readfrombuffer(buf) 
 607          self.__field_slotnumber=UINT(**{'sizeinbytes': 2}) 
 608          self.__field_slotnumber.readfrombuffer(buf) 
 609          self.__field_entry=pbentry() 
 610          self.__field_entry.readfrombuffer(buf) 
 611          self._bufferendoffset=buf.getcurrentoffset() 

 612   
 613   

 614 -    def __getfield_cmd(self): 

 615          try: self.__field_cmd 
 616          except: 
 617              self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x82}) 
 618          return self.__field_cmd.getvalue() 

 619   

 620 -    def __setfield_cmd(self, value): 

 621          if isinstance(value,UINT): 
 622              self.__field_cmd=value 
 623          else: 
 624              self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'constant': 0x82}) 

 625   

 626 -    def __delfield_cmd(self): del self.__field_cmd 

 627   
 628      cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None) 
 629   

 630 -    def __getfield_slotnumber(self): 

 631          return self.__field_slotnumber.getvalue() 

 632   

 633 -    def __setfield_slotnumber(self, value): 

 634          if isinstance(value,UINT): 
 635              self.__field_slotnumber=value 
 636          else: 
 637              self.__field_slotnumber=UINT(value,**{'sizeinbytes': 2}) 

 638   

 639 -    def __delfield_slotnumber(self): del self.__field_slotnumber 

 640   
 641      slotnumber=property(__getfield_slotnumber, __setfield_slotnumber, __delfield_slotnumber, None) 
 642   

 643 -    def __getfield_entry(self): 

 644          return self.__field_entry.getvalue() 

 645   

 646 -    def __setfield_entry(self, value): 

 647          if isinstance(value,pbentry): 
 648              self.__field_entry=value 
 649          else: 
 650              self.__field_entry=pbentry(value,) 

 651   

 652 -    def __delfield_entry(self): del self.__field_entry 

 653   
 654      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
 655   

 656 -    def iscontainer(self): 

 657          return True 

 658   

 659 -    def containerelements(self): 

 660          yield ('cmd', self.__field_cmd, None) 
 661          yield ('slotnumber', self.__field_slotnumber, None) 
 662          yield ('entry', self.__field_entry, None) 

 663   
 664   
 665   
 666   

 667 -class writepbentryresponse(BaseProtogenClass): 

 668      __fields=['cmd', 'slotnumber'] 
 669   

 670 -    def __init__(self, *args, **kwargs): 

 671          dict={} 
 672          # What was supplied to this function 
 673          dict.update(kwargs) 
 674          # Parent constructor 
 675          super(writepbentryresponse,self).__init__(**dict) 
 676          if self.__class__ is writepbentryresponse: 
 677              self._update(args,dict) 

 678   
 679   

 680 -    def getfields(self): 

 681          return self.__fields 

 682   
 683   

 684 -    def _update(self, args, kwargs): 

 685          super(writepbentryresponse,self)._update(args,kwargs) 
 686          keys=kwargs.keys() 
 687          for key in keys: 
 688              if key in self.__fields: 
 689                  setattr(self, key, kwargs[key]) 
 690                  del kwargs[key] 
 691          # Were any unrecognized kwargs passed in? 
 692          if __debug__: 
 693              self._complainaboutunusedargs(writepbentryresponse,kwargs) 
 694          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 

 695          # Make all P fields that haven't already been constructed 
 696   
 697   

 698 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 

 699          'Writes this packet to the supplied buffer' 
 700          self._bufferstartoffset=buf.getcurrentoffset() 
 701          self.__field_cmd.writetobuffer(buf) 
 702          self.__field_slotnumber.writetobuffer(buf) 
 703          self._bufferendoffset=buf.getcurrentoffset() 
 704          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 

 705   
 706   

 707 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 

 708          'Reads this packet from the supplied buffer' 
 709          self._bufferstartoffset=buf.getcurrentoffset() 
 710          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 711          self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x82}) 
 712          self.__field_cmd.readfrombuffer(buf) 
 713          self.__field_slotnumber=UINT(**{'sizeinbytes': 2}) 
 714          self.__field_slotnumber.readfrombuffer(buf) 
 715          self._bufferendoffset=buf.getcurrentoffset() 

 716   
 717   

 718 -    def __getfield_cmd(self): 

 719          return self.__field_cmd.getvalue() 

 720   

 721 -    def __setfield_cmd(self, value): 

 722          if isinstance(value,UINT): 
 723              self.__field_cmd=value 
 724          else: 
 725              self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'constant': 0x82}) 

 726   

 727 -    def __delfield_cmd(self): del self.__field_cmd 

 728   
 729      cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None) 
 730   

 731 -    def __getfield_slotnumber(self): 

 732          return self.__field_slotnumber.getvalue() 

 733   

 734 -    def __setfield_slotnumber(self, value): 

 735          if isinstance(value,UINT): 
 736              self.__field_slotnumber=value 
 737          else: 
 738              self.__field_slotnumber=UINT(value,**{'sizeinbytes': 2}) 

 739   

 740 -    def __delfield_slotnumber(self): del self.__field_slotnumber 

 741   
 742      slotnumber=property(__getfield_slotnumber, __setfield_slotnumber, __delfield_slotnumber, None) 
 743   

 744 -    def iscontainer(self): 

 745          return True 

 746   

 747 -    def containerelements(self): 

 748          yield ('cmd', self.__field_cmd, None) 
 749          yield ('slotnumber', self.__field_slotnumber, None) 

 750   
 751   
 752   
 753   

 754 -class pbentry(BaseProtogenClass): 

 755      __fields=['secret', 'group', 'previous', 'next', 'mobile', 'home', 'office', 'pager', 'fax', 'name', 'email', 'wireless', 'memo', 'ringtone', 'msgringtone', 'wallpaper'] 
 756   

 757 -    def __init__(self, *args, **kwargs): 

 758          dict={} 
 759          # What was supplied to this function 
 760          dict.update(kwargs) 
 761          # Parent constructor 
 762          super(pbentry,self).__init__(**dict) 
 763          if self.__class__ is pbentry: 
 764              self._update(args,dict) 

 765   
 766   

 767 -    def getfields(self): 

 768          return self.__fields 

 769   
 770   

 771 -    def _update(self, args, kwargs): 

 772          super(pbentry,self)._update(args,kwargs) 
 773          keys=kwargs.keys() 
 774          for key in keys: 
 775              if key in self.__fields: 
 776                  setattr(self, key, kwargs[key]) 
 777                  del kwargs[key] 
 778          # Were any unrecognized kwargs passed in? 
 779          if __debug__: 
 780              self._complainaboutunusedargs(pbentry,kwargs) 
 781          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 

 782          # Make all P fields that haven't already been constructed 
 783   
 784   

 785 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 

 786          'Writes this packet to the supplied buffer' 
 787          self._bufferstartoffset=buf.getcurrentoffset() 
 788          self.__field_secret.writetobuffer(buf) 
 789          self.__field_group.writetobuffer(buf) 
 790          self.__field_previous.writetobuffer(buf) 
 791          self.__field_next.writetobuffer(buf) 
 792          self.__field_mobile.writetobuffer(buf) 
 793          self.__field_home.writetobuffer(buf) 
 794          self.__field_office.writetobuffer(buf) 
 795          self.__field_pager.writetobuffer(buf) 
 796          self.__field_fax.writetobuffer(buf) 
 797          self.__field_name.writetobuffer(buf) 
 798          self.__field_email.writetobuffer(buf) 
 799          self.__field_wireless.writetobuffer(buf) 
 800          self.__field_memo.writetobuffer(buf) 
 801          self.__field_ringtone.writetobuffer(buf) 
 802          self.__field_msgringtone.writetobuffer(buf) 
 803          self.__field_wallpaper.writetobuffer(buf) 
 804          self._bufferendoffset=buf.getcurrentoffset() 
 805          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 

 806   
 807   

 808 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 

 809          'Reads this packet from the supplied buffer' 
 810          self._bufferstartoffset=buf.getcurrentoffset() 
 811          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 812          self.__field_secret=UINT(**{'sizeinbytes': 1}) 
 813          self.__field_secret.readfrombuffer(buf) 
 814          self.__field_group=UINT(**{'sizeinbytes': 1}) 
 815          self.__field_group.readfrombuffer(buf) 
 816          self.__field_previous=UINT(**{'sizeinbytes': 2}) 
 817          self.__field_previous.readfrombuffer(buf) 
 818          self.__field_next=UINT(**{'sizeinbytes': 2}) 
 819          self.__field_next.readfrombuffer(buf) 
 820          self.__field_mobile=COUNTEDBUFFEREDSTRING(**{'sizeinbytes': 33}) 
 821          self.__field_mobile.readfrombuffer(buf) 
 822          self.__field_home=COUNTEDBUFFEREDSTRING(**{'sizeinbytes': 33}) 
 823          self.__field_home.readfrombuffer(buf) 
 824          self.__field_office=COUNTEDBUFFEREDSTRING(**{'sizeinbytes': 33}) 
 825          self.__field_office.readfrombuffer(buf) 
 826          self.__field_pager=COUNTEDBUFFEREDSTRING(**{'sizeinbytes': 33}) 
 827          self.__field_pager.readfrombuffer(buf) 
 828          self.__field_fax=COUNTEDBUFFEREDSTRING(**{'sizeinbytes': 33}) 
 829          self.__field_fax.readfrombuffer(buf) 
 830          self.__field_name=USTRING(**{'sizeinbytes': 17}) 
 831          self.__field_name.readfrombuffer(buf) 
 832          self.__field_email=USTRING(**{'sizeinbytes': 49}) 
 833          self.__field_email.readfrombuffer(buf) 
 834          self.__field_wireless=USTRING(**{'sizeinbytes': 49}) 
 835          self.__field_wireless.readfrombuffer(buf) 
 836          self.__field_memo=USTRING(**{'sizeinbytes': 49}) 
 837          self.__field_memo.readfrombuffer(buf) 
 838          self.__field_ringtone=UINT(**{'sizeinbytes': 2}) 
 839          self.__field_ringtone.readfrombuffer(buf) 
 840          self.__field_msgringtone=UINT(**{'sizeinbytes': 2}) 
 841          self.__field_msgringtone.readfrombuffer(buf) 
 842          self.__field_wallpaper=UINT(**{'sizeinbytes': 2}) 
 843          self.__field_wallpaper.readfrombuffer(buf) 
 844          self._bufferendoffset=buf.getcurrentoffset() 

 845   
 846   

 847 -    def __getfield_secret(self): 

 848          return self.__field_secret.getvalue() 

 849   

 850 -    def __setfield_secret(self, value): 

 851          if isinstance(value,UINT): 
 852              self.__field_secret=value 
 853          else: 
 854              self.__field_secret=UINT(value,**{'sizeinbytes': 1}) 

 855   

 856 -    def __delfield_secret(self): del self.__field_secret 

 857   
 858      secret=property(__getfield_secret, __setfield_secret, __delfield_secret, "non-zero if entry is secret/locked") 
 859   

 860 -    def __getfield_group(self): 

 861          return self.__field_group.getvalue() 

 862   

 863 -    def __setfield_group(self, value): 

 864          if isinstance(value,UINT): 
 865              self.__field_group=value 
 866          else: 
 867              self.__field_group=UINT(value,**{'sizeinbytes': 1}) 

 868   

 869 -    def __delfield_group(self): del self.__field_group 

 870   
 871      group=property(__getfield_group, __setfield_group, __delfield_group, None) 
 872   

 873 -    def __getfield_previous(self): 

 874          return self.__field_previous.getvalue() 

 875   

 876 -    def __setfield_previous(self, value): 

 877          if isinstance(value,UINT): 
 878              self.__field_previous=value 
 879          else: 
 880              self.__field_previous=UINT(value,**{'sizeinbytes': 2}) 

 881   

 882 -    def __delfield_previous(self): del self.__field_previous 

 883   
 884      previous=property(__getfield_previous, __setfield_previous, __delfield_previous, "?index number for previous entry") 
 885   

 886 -    def __getfield_next(self): 

 887          return self.__field_next.getvalue() 

 888   

 889 -    def __setfield_next(self, value): 

 890          if isinstance(value,UINT): 
 891              self.__field_next=value 
 892          else: 
 893              self.__field_next=UINT(value,**{'sizeinbytes': 2}) 

 894   

 895 -    def __delfield_next(self): del self.__field_next 

 896   
 897      next=property(__getfield_next, __setfield_next, __delfield_next, "?index number for next entry") 
 898   

 899 -    def __getfield_mobile(self): 

 900          return self.__field_mobile.getvalue() 

 901   

 902 -    def __setfield_mobile(self, value): 

 903          if isinstance(value,COUNTEDBUFFEREDSTRING): 
 904              self.__field_mobile=value 
 905          else: 
 906              self.__field_mobile=COUNTEDBUFFEREDSTRING(value,**{'sizeinbytes': 33}) 

 907   

 908 -    def __delfield_mobile(self): del self.__field_mobile 

 909   
 910      mobile=property(__getfield_mobile, __setfield_mobile, __delfield_mobile, None) 
 911   

 912 -    def __getfield_home(self): 

 913          return self.__field_home.getvalue() 

 914   

 915 -    def __setfield_home(self, value): 

 916          if isinstance(value,COUNTEDBUFFEREDSTRING): 
 917              self.__field_home=value 
 918          else: 
 919              self.__field_home=COUNTEDBUFFEREDSTRING(value,**{'sizeinbytes': 33}) 

 920   

 921 -    def __delfield_home(self): del self.__field_home 

 922   
 923      home=property(__getfield_home, __setfield_home, __delfield_home, None) 
 924   

 925 -    def __getfield_office(self): 

 926          return self.__field_office.getvalue() 

 927   

 928 -    def __setfield_office(self, value): 

 929          if isinstance(value,COUNTEDBUFFEREDSTRING): 
 930              self.__field_office=value 
 931          else: 
 932              self.__field_office=COUNTEDBUFFEREDSTRING(value,**{'sizeinbytes': 33}) 

 933   

 934 -    def __delfield_office(self): del self.__field_office 

 935   
 936      office=property(__getfield_office, __setfield_office, __delfield_office, None) 
 937   

 938 -    def __getfield_pager(self): 

 939          return self.__field_pager.getvalue() 

 940   

 941 -    def __setfield_pager(self, value): 

 942          if isinstance(value,COUNTEDBUFFEREDSTRING): 
 943              self.__field_pager=value 
 944          else: 
 945              self.__field_pager=COUNTEDBUFFEREDSTRING(value,**{'sizeinbytes': 33}) 

 946   

 947 -    def __delfield_pager(self): del self.__field_pager 

 948   
 949      pager=property(__getfield_pager, __setfield_pager, __delfield_pager, None) 
 950   

 951 -    def __getfield_fax(self): 

 952          return self.__field_fax.getvalue() 

 953   

 954 -    def __setfield_fax(self, value): 

 955          if isinstance(value,COUNTEDBUFFEREDSTRING): 
 956              self.__field_fax=value 
 957          else: 
 958              self.__field_fax=COUNTEDBUFFEREDSTRING(value,**{'sizeinbytes': 33}) 

 959   

 960 -    def __delfield_fax(self): del self.__field_fax 

 961   
 962      fax=property(__getfield_fax, __setfield_fax, __delfield_fax, None) 
 963   

 964 -    def __getfield_name(self): 

 965          return self.__field_name.getvalue() 

 966   

 967 -    def __setfield_name(self, value): 

 968          if isinstance(value,USTRING): 
 969              self.__field_name=value 
 970          else: 
 971              self.__field_name=USTRING(value,**{'sizeinbytes': 17}) 

 972   

 973 -    def __delfield_name(self): del self.__field_name 

 974   
 975      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
 976   

 977 -    def __getfield_email(self): 

 978          return self.__field_email.getvalue() 

 979   

 980 -    def __setfield_email(self, value): 

 981          if isinstance(value,USTRING): 
 982              self.__field_email=value 
 983          else: 
 984              self.__field_email=USTRING(value,**{'sizeinbytes': 49}) 

 985   

 986 -    def __delfield_email(self): del self.__field_email 

 987   
 988      email=property(__getfield_email, __setfield_email, __delfield_email, None) 
 989   

 990 -    def __getfield_wireless(self): 

 991          return self.__field_wireless.getvalue() 

 992   

 993 -    def __setfield_wireless(self, value): 

 994          if isinstance(value,USTRING): 
 995              self.__field_wireless=value 
 996          else: 
 997              self.__field_wireless=USTRING(value,**{'sizeinbytes': 49}) 

 998   

 999 -    def __delfield_wireless(self): del self.__field_wireless 

1000   
1001      wireless=property(__getfield_wireless, __setfield_wireless, __delfield_wireless, None) 
1002   

1003 -    def __getfield_memo(self): 

1004          return self.__field_memo.getvalue() 

1005   

1006 -    def __setfield_memo(self, value): 

1007          if isinstance(value,USTRING): 
1008              self.__field_memo=value 
1009          else: 
1010              self.__field_memo=USTRING(value,**{'sizeinbytes': 49}) 

1011   

1012 -    def __delfield_memo(self): del self.__field_memo 

1013   
1014      memo=property(__getfield_memo, __setfield_memo, __delfield_memo, None) 
1015   

1016 -    def __getfield_ringtone(self): 

1017          return self.__field_ringtone.getvalue() 

1018   

1019 -    def __setfield_ringtone(self, value): 

1020          if isinstance(value,UINT): 
1021              self.__field_ringtone=value 
1022          else: 
1023              self.__field_ringtone=UINT(value,**{'sizeinbytes': 2}) 

1024   

1025 -    def __delfield_ringtone(self): del self.__field_ringtone 

1026   
1027      ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 
1028   

1029 -    def __getfield_msgringtone(self): 

1030          return self.__field_msgringtone.getvalue() 

1031   

1032 -    def __setfield_msgringtone(self, value): 

1033          if isinstance(value,UINT): 
1034              self.__field_msgringtone=value 
1035          else: 
1036              self.__field_msgringtone=UINT(value,**{'sizeinbytes': 2}) 

1037   

1038 -    def __delfield_msgringtone(self): del self.__field_msgringtone 

1039   
1040      msgringtone=property(__getfield_msgringtone, __setfield_msgringtone, __delfield_msgringtone, None) 
1041   

1042 -    def __getfield_wallpaper(self): 

1043          return self.__field_wallpaper.getvalue() 

1044   

1045 -    def __setfield_wallpaper(self, value): 

1046          if isinstance(value,UINT): 
1047              self.__field_wallpaper=value 
1048          else: 
1049              self.__field_wallpaper=UINT(value,**{'sizeinbytes': 2}) 

1050   

1051 -    def __delfield_wallpaper(self): del self.__field_wallpaper 

1052   
1053      wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None) 
1054   

1055 -    def iscontainer(self): 

1056          return True 

1057   

1058 -    def containerelements(self): 

1059          yield ('secret', self.__field_secret, "non-zero if entry is secret/locked") 
1060          yield ('group', self.__field_group, None) 
1061          yield ('previous', self.__field_previous, "?index number for previous entry") 
1062          yield ('next', self.__field_next, "?index number for next entry") 
1063          yield ('mobile', self.__field_mobile, None) 
1064          yield ('home', self.__field_home, None) 
1065          yield ('office', self.__field_office, None) 
1066          yield ('pager', self.__field_pager, None) 
1067          yield ('fax', self.__field_fax, None) 
1068          yield ('name', self.__field_name, None) 
1069          yield ('email', self.__field_email, None) 
1070          yield ('wireless', self.__field_wireless, None) 
1071          yield ('memo', self.__field_memo, None) 
1072          yield ('ringtone', self.__field_ringtone, None) 
1073          yield ('msgringtone', self.__field_msgringtone, None) 
1074          yield ('wallpaper', self.__field_wallpaper, None) 

1075   
1076   
1077   
1078   

1079 -class readgroupentryrequest(BaseProtogenClass): 

1080      __fields=['cmd', 'number'] 
1081   

1082 -    def __init__(self, *args, **kwargs): 

1083          dict={} 
1084          # What was supplied to this function 
1085          dict.update(kwargs) 
1086          # Parent constructor 
1087          super(readgroupentryrequest,self).__init__(**dict) 
1088          if self.__class__ is readgroupentryrequest: 
1089              self._update(args,dict) 

1090   
1091   

1092 -    def getfields(self): 

1093          return self.__fields 

1094   
1095   

1096 -    def _update(self, args, kwargs): 

1097          super(readgroupentryrequest,self)._update(args,kwargs) 
1098          keys=kwargs.keys() 
1099          for key in keys: 
1100              if key in self.__fields: 
1101                  setattr(self, key, kwargs[key]) 
1102                  del kwargs[key] 
1103          # Were any unrecognized kwargs passed in? 
1104          if __debug__: 
1105              self._complainaboutunusedargs(readgroupentryrequest,kwargs) 
1106          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 

1107          # Make all P fields that haven't already been constructed 
1108   
1109   

1110 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 

1111          'Writes this packet to the supplied buffer' 
1112          self._bufferstartoffset=buf.getcurrentoffset() 
1113          try: self.__field_cmd 
1114          except: 
1115              self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x81}) 
1116          self.__field_cmd.writetobuffer(buf) 
1117          self.__field_number.writetobuffer(buf) 
1118          self._bufferendoffset=buf.getcurrentoffset() 
1119          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 

1120   
1121   

1122 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 

1123          'Reads this packet from the supplied buffer' 
1124          self._bufferstartoffset=buf.getcurrentoffset() 
1125          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1126          self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x81}) 
1127          self.__field_cmd.readfrombuffer(buf) 
1128          self.__field_number=UINT(**{'sizeinbytes': 1}) 
1129          self.__field_number.readfrombuffer(buf) 
1130          self._bufferendoffset=buf.getcurrentoffset() 

1131   
1132   

1133 -    def __getfield_cmd(self): 

1134          try: self.__field_cmd 
1135          except: 
1136              self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x81}) 
1137          return self.__field_cmd.getvalue() 

1138   

1139 -    def __setfield_cmd(self, value): 

1140          if isinstance(value,UINT): 
1141              self.__field_cmd=value 
1142          else: 
1143              self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'constant': 0x81}) 

1144   

1145 -    def __delfield_cmd(self): del self.__field_cmd 

1146   
1147      cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None) 
1148   

1149 -    def __getfield_number(self): 

1150          return self.__field_number.getvalue() 

1151   

1152 -    def __setfield_number(self, value): 

1153          if isinstance(value,UINT): 
1154              self.__field_number=value 
1155          else: 
1156              self.__field_number=UINT(value,**{'sizeinbytes': 1}) 

1157   

1158 -    def __delfield_number(self): del self.__field_number 

1159   
1160      number=property(__getfield_number, __setfield_number, __delfield_number, None) 
1161   

1162 -    def iscontainer(self): 

1163          return True 

1164   

1165 -    def containerelements(self): 

1166          yield ('cmd', self.__field_cmd, None) 
1167          yield ('number', self.__field_number, None) 

1168   
1169   
1170   
1171   

1172 -class readgroupentryresponse(BaseProtogenClass): 

1173      __fields=['cmd', 'number', 'anothergroupnum', 'dunno', 'name', 'nummembers'] 
1174   

1175 -    def __init__(self, *args, **kwargs): 

1176          dict={} 
1177          # What was supplied to this function 
1178          dict.update(kwargs) 
1179          # Parent constructor 
1180          super(readgroupentryresponse,self).__init__(**dict) 
1181          if self.__class__ is readgroupentryresponse: 
1182              self._update(args,dict) 

1183   
1184   

1185 -    def getfields(self): 

1186          return self.__fields 

1187   
1188   

1189 -    def _update(self, args, kwargs): 

1190          super(readgroupentryresponse,self)._update(args,kwargs) 
1191          keys=kwargs.keys() 
1192          for key in keys: 
1193              if key in self.__fields: 
1194                  setattr(self, key, kwargs[key]) 
1195                  del kwargs[key] 
1196          # Were any unrecognized kwargs passed in? 
1197          if __debug__: 
1198              self._complainaboutunusedargs(readgroupentryresponse,kwargs) 
1199          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 

1200          # Make all P fields that haven't already been constructed 
1201   
1202   

1203 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 

1204          'Writes this packet to the supplied buffer' 
1205          self._bufferstartoffset=buf.getcurrentoffset() 
1206          self.__field_cmd.writetobuffer(buf) 
1207          self.__field_number.writetobuffer(buf) 
1208          self.__field_anothergroupnum.writetobuffer(buf) 
1209          self.__field_dunno.writetobuffer(buf) 
1210          self.__field_name.writetobuffer(buf) 
1211          self.__field_nummembers.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': 0x81}) 
1221          self.__field_cmd.readfrombuffer(buf) 
1222          self.__field_number=UINT(**{'sizeinbytes': 1}) 
1223          self.__field_number.readfrombuffer(buf) 
1224          self.__field_anothergroupnum=UINT(**{'sizeinbytes': 1}) 
1225          self.__field_anothergroupnum.readfrombuffer(buf) 
1226          self.__field_dunno=UINT(**{'sizeinbytes': 2}) 
1227          self.__field_dunno.readfrombuffer(buf) 
1228          self.__field_name=USTRING(**{'sizeinbytes': 17}) 
1229          self.__field_name.readfrombuffer(buf) 
1230          self.__field_nummembers=UINT(**{'sizeinbytes': 2}) 
1231          self.__field_nummembers.readfrombuffer(buf) 
1232          self._bufferendoffset=buf.getcurrentoffset() 

1233   
1234   

1235 -    def __getfield_cmd(self): 

1236          return self.__field_cmd.getvalue() 

1237   

1238 -    def __setfield_cmd(self, value): 

1239          if isinstance(value,UINT): 
1240              self.__field_cmd=value 
1241          else: 
1242              self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'constant': 0x81}) 

1243   

1244 -    def __delfield_cmd(self): del self.__field_cmd 

1245   
1246      cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None) 
1247   

1248 -    def __getfield_number(self): 

1249          return self.__field_number.getvalue() 

1250   

1251 -    def __setfield_number(self, value): 

1252          if isinstance(value,UINT): 
1253              self.__field_number=value 
1254          else: 
1255              self.__field_number=UINT(value,**{'sizeinbytes': 1}) 

1256   

1257 -    def __delfield_number(self): del self.__field_number 

1258   
1259      number=property(__getfield_number, __setfield_number, __delfield_number, None) 
1260   

1261 -    def __getfield_anothergroupnum(self): 

1262          return self.__field_anothergroupnum.getvalue() 

1263   

1264 -    def __setfield_anothergroupnum(self, value): 

1265          if isinstance(value,UINT): 
1266              self.__field_anothergroupnum=value 
1267          else: 
1268              self.__field_anothergroupnum=UINT(value,**{'sizeinbytes': 1}) 

1269   

1270 -    def __delfield_anothergroupnum(self): del self.__field_anothergroupnum 

1271   
1272      anothergroupnum=property(__getfield_anothergroupnum, __setfield_anothergroupnum, __delfield_anothergroupnum, None) 
1273   

1274 -    def __getfield_dunno(self): 

1275          return self.__field_dunno.getvalue() 

1276   

1277 -    def __setfield_dunno(self, value): 

1278          if isinstance(value,UINT): 
1279              self.__field_dunno=value 
1280          else: 
1281              self.__field_dunno=UINT(value,**{'sizeinbytes': 2}) 

1282   

1283 -    def __delfield_dunno(self): del self.__field_dunno 

1284   
1285      dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, "first member?") 
1286   

1287 -    def __getfield_name(self): 

1288          return self.__field_name.getvalue() 

1289   

1290 -    def __setfield_name(self, value): 

1291          if isinstance(value,USTRING): 
1292              self.__field_name=value 
1293          else: 
1294              self.__field_name=USTRING(value,**{'sizeinbytes': 17}) 

1295   

1296 -    def __delfield_name(self): del self.__field_name 

1297   
1298      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
1299   

1300 -    def __getfield_nummembers(self): 

1301          return self.__field_nummembers.getvalue() 

1302   

1303 -    def __setfield_nummembers(self, value): 

1304          if isinstance(value,UINT): 
1305              self.__field_nummembers=value 
1306          else: 
1307              self.__field_nummembers=UINT(value,**{'sizeinbytes': 2}) 

1308   

1309 -    def __delfield_nummembers(self): del self.__field_nummembers 

1310   
1311      nummembers=property(__getfield_nummembers, __setfield_nummembers, __delfield_nummembers, "how many members of the group") 
1312   

1313 -    def iscontainer(self): 

1314          return True 

1315   

1316 -    def containerelements(self): 

1317          yield ('cmd', self.__field_cmd, None) 
1318          yield ('number', self.__field_number, None) 
1319          yield ('anothergroupnum', self.__field_anothergroupnum, None) 
1320          yield ('dunno', self.__field_dunno, "first member?") 
1321          yield ('name', self.__field_name, None) 
1322          yield ('nummembers', self.__field_nummembers, "how many members of the group") 

1323   
1324   
1325   
1326   

1327 -class writegroupentryrequest(BaseProtogenClass): 

1328      __fields=['cmd', 'number', 'anothernumber', 'dunno', 'name', 'nummembers'] 
1329   

1330 -    def __init__(self, *args, **kwargs): 

1331          dict={} 
1332          # What was supplied to this function 
1333          dict.update(kwargs) 
1334          # Parent constructor 
1335          super(writegroupentryrequest,self).__init__(**dict) 
1336          if self.__class__ is writegroupentryrequest: 
1337              self._update(args,dict) 

1338   
1339   

1340 -    def getfields(self): 

1341          return self.__fields 

1342   
1343   

1344 -    def _update(self, args, kwargs): 

1345          super(writegroupentryrequest,self)._update(args,kwargs) 
1346          keys=kwargs.keys() 
1347          for key in keys: 
1348              if key in self.__fields: 
1349                  setattr(self, key, kwargs[key]) 
1350                  del kwargs[key] 
1351          # Were any unrecognized kwargs passed in? 
1352          if __debug__: 
1353              self._complainaboutunusedargs(writegroupentryrequest,kwargs) 
1354          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 

1355          # Make all P fields that haven't already been constructed 
1356   
1357   

1358 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 

1359          'Writes this packet to the supplied buffer' 
1360          self._bufferstartoffset=buf.getcurrentoffset() 
1361          try: self.__field_cmd 
1362          except: 
1363              self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x80}) 
1364          self.__field_cmd.writetobuffer(buf) 
1365          self.__field_number.writetobuffer(buf) 
1366          self.__field_anothernumber.writetobuffer(buf) 
1367          try: self.__field_dunno 
1368          except: 
1369              self.__field_dunno=UINT(**{'sizeinbytes': 2, 'constant': 0xffff}) 
1370          self.__field_dunno.writetobuffer(buf) 
1371          self.__field_name.writetobuffer(buf) 
1372          self.__field_nummembers.writetobuffer(buf) 
1373          self._bufferendoffset=buf.getcurrentoffset() 
1374          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 

1375   
1376   

1377 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 

1378          'Reads this packet from the supplied buffer' 
1379          self._bufferstartoffset=buf.getcurrentoffset() 
1380          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1381          self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x80}) 
1382          self.__field_cmd.readfrombuffer(buf) 
1383          self.__field_number=UINT(**{'sizeinbytes': 1}) 
1384          self.__field_number.readfrombuffer(buf) 
1385          self.__field_anothernumber=UINT(**{'sizeinbytes': 1}) 
1386          self.__field_anothernumber.readfrombuffer(buf) 
1387          self.__field_dunno=UINT(**{'sizeinbytes': 2, 'constant': 0xffff}) 
1388          self.__field_dunno.readfrombuffer(buf) 
1389          self.__field_name=USTRING(**{'sizeinbytes': 17}) 
1390          self.__field_name.readfrombuffer(buf) 
1391          self.__field_nummembers=UINT(**{'sizeinbytes': 2}) 
1392          self.__field_nummembers.readfrombuffer(buf) 
1393          self._bufferendoffset=buf.getcurrentoffset() 

1394   
1395   

1396 -    def __getfield_cmd(self): 

1397          try: self.__field_cmd 
1398          except: 
1399              self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x80}) 
1400          return self.__field_cmd.getvalue() 

1401   

1402 -    def __setfield_cmd(self, value): 

1403          if isinstance(value,UINT): 
1404              self.__field_cmd=value 
1405          else: 
1406              self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'constant': 0x80}) 

1407   

1408 -    def __delfield_cmd(self): del self.__field_cmd 

1409   
1410      cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None) 
1411   

1412 -    def __getfield_number(self): 

1413          return self.__field_number.getvalue() 

1414   

1415 -    def __setfield_number(self, value): 

1416          if isinstance(value,UINT): 
1417              self.__field_number=value 
1418          else: 
1419              self.__field_number=UINT(value,**{'sizeinbytes': 1}) 

1420   

1421 -    def __delfield_number(self): del self.__field_number 

1422   
1423      number=property(__getfield_number, __setfield_number, __delfield_number, None) 
1424   

1425 -    def __getfield_anothernumber(self): 

1426          return self.__field_anothernumber.getvalue() 

1427   

1428 -    def __setfield_anothernumber(self, value): 

1429          if isinstance(value,UINT): 
1430              self.__field_anothernumber=value 
1431          else: 
1432              self.__field_anothernumber=UINT(value,**{'sizeinbytes': 1}) 

1433   

1434 -    def __delfield_anothernumber(self): del self.__field_anothernumber 

1435   
1436      anothernumber=property(__getfield_anothernumber, __setfield_anothernumber, __delfield_anothernumber, "same as number") 
1437   

1438 -    def __getfield_dunno(self): 

1439          try: self.__field_dunno 
1440          except: 
1441              self.__field_dunno=UINT(**{'sizeinbytes': 2, 'constant': 0xffff}) 
1442          return self.__field_dunno.getvalue() 

1443   

1444 -    def __setfield_dunno(self, value): 

1445          if isinstance(value,UINT): 
1446              self.__field_dunno=value 
1447          else: 
1448              self.__field_dunno=UINT(value,**{'sizeinbytes': 2, 'constant': 0xffff}) 

1449   

1450 -    def __delfield_dunno(self): del self.__field_dunno 

1451   
1452      dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, "?first member of the group") 
1453   

1454 -    def __getfield_name(self): 

1455          return self.__field_name.getvalue() 

1456   

1457 -    def __setfield_name(self, value): 

1458          if isinstance(value,USTRING): 
1459              self.__field_name=value 
1460          else: 
1461              self.__field_name=USTRING(value,**{'sizeinbytes': 17}) 

1462   

1463 -    def __delfield_name(self): del self.__field_name 

1464   
1465      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
1466   

1467 -    def __getfield_nummembers(self): 

1468          return self.__field_nummembers.getvalue() 

1469   

1470 -    def __setfield_nummembers(self, value): 

1471          if isinstance(value,UINT): 
1472              self.__field_nummembers=value 
1473          else: 
1474              self.__field_nummembers=UINT(value,**{'sizeinbytes': 2}) 

1475   

1476 -    def __delfield_nummembers(self): del self.__field_nummembers 

1477   
1478      nummembers=property(__getfield_nummembers, __setfield_nummembers, __delfield_nummembers, None) 
1479   

1480 -    def iscontainer(self): 

1481          return True 

1482   

1483 -    def containerelements(self): 

1484          yield ('cmd', self.__field_cmd, None) 
1485          yield ('number', self.__field_number, None) 
1486          yield ('anothernumber', self.__field_anothernumber, "same as number") 
1487          yield ('dunno', self.__field_dunno, "?first member of the group") 
1488          yield ('name', self.__field_name, None) 
1489          yield ('nummembers', self.__field_nummembers, None) 

1490   
1491   
1492   
1493   

1494 -class writegroupentryresponse(BaseProtogenClass): 

1495      __fields=['cmd'] 
1496   

1497 -    def __init__(self, *args, **kwargs): 

1498          dict={} 
1499          # What was supplied to this function 
1500          dict.update(kwargs) 
1501          # Parent constructor 
1502          super(writegroupentryresponse,self).__init__(**dict) 
1503          if self.__class__ is writegroupentryresponse: 
1504              self._update(args,dict) 

1505   
1506   

1507 -    def getfields(self): 

1508          return self.__fields 

1509   
1510   

1511 -    def _update(self, args, kwargs): 

1512          super(writegroupentryresponse,self)._update(args,kwargs) 
1513          keys=kwargs.keys() 
1514          for key in keys: 
1515              if key in self.__fields: 
1516                  setattr(self, key, kwargs[key]) 
1517                  del kwargs[key] 
1518          # Were any unrecognized kwargs passed in? 
1519          if __debug__: 
1520              self._complainaboutunusedargs(writegroupentryresponse,kwargs) 
1521          if len(args): 
1522              dict2={'sizeinbytes': 1, 'constant': 0x80} 
1523              dict2.update(kwargs) 
1524              kwargs=dict2 
1525              self.__field_cmd=UINT(*args,**dict2) 

1526          # Make all P fields that haven't already been constructed 
1527   
1528   

1529 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 

1530          'Writes this packet to the supplied buffer' 
1531          self._bufferstartoffset=buf.getcurrentoffset() 
1532          self.__field_cmd.writetobuffer(buf) 
1533          self._bufferendoffset=buf.getcurrentoffset() 
1534          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 

1535   
1536   

1537 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 

1538          'Reads this packet from the supplied buffer' 
1539          self._bufferstartoffset=buf.getcurrentoffset() 
1540          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1541          self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x80}) 
1542          self.__field_cmd.readfrombuffer(buf) 
1543          self._bufferendoffset=buf.getcurrentoffset() 

1544   
1545   

1546 -    def __getfield_cmd(self): 

1547          return self.__field_cmd.getvalue() 

1548   

1549 -    def __setfield_cmd(self, value): 

1550          if isinstance(value,UINT): 
1551              self.__field_cmd=value 
1552          else: 
1553              self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'constant': 0x80}) 

1554   

1555 -    def __delfield_cmd(self): del self.__field_cmd 

1556   
1557      cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None) 
1558   

1559 -    def iscontainer(self): 

1560          return True 

1561   

1562 -    def containerelements(self): 

1563          yield ('cmd', self.__field_cmd, None) 

1564   
1565   
1566   
1567   

1568 -class dunnorequest(BaseProtogenClass): 

1569      __fields=['cmd', 'cmd2', 'cmd3', 'which'] 
1570   

1571 -    def __init__(self, *args, **kwargs): 

1572          dict={} 
1573          # What was supplied to this function 
1574          dict.update(kwargs) 
1575          # Parent constructor 
1576          super(dunnorequest,self).__init__(**dict) 
1577          if self.__class__ is dunnorequest: 
1578              self._update(args,dict) 

1579   
1580   

1581 -    def getfields(self): 

1582          return self.__fields 

1583   
1584   

1585 -    def _update(self, args, kwargs): 

1586          super(dunnorequest,self)._update(args,kwargs) 
1587          keys=kwargs.keys() 
1588          for key in keys: 
1589              if key in self.__fields: 
1590                  setattr(self, key, kwargs[key]) 
1591                  del kwargs[key] 
1592          # Were any unrecognized kwargs passed in? 
1593          if __debug__: 
1594              self._complainaboutunusedargs(dunnorequest,kwargs) 
1595          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 

1596          # Make all P fields that haven't already been constructed 
1597   
1598   

1599 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 

1600          'Writes this packet to the supplied buffer' 
1601          self._bufferstartoffset=buf.getcurrentoffset() 
1602          try: self.__field_cmd 
1603          except: 
1604              self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x26}) 
1605          self.__field_cmd.writetobuffer(buf) 
1606          try: self.__field_cmd2 
1607          except: 
1608              self.__field_cmd2=UINT(**{'sizeinbytes': 1, 'constant': 0xf7}) 
1609          self.__field_cmd2.writetobuffer(buf) 
1610          try: self.__field_cmd3 
1611          except: 
1612              self.__field_cmd3=UINT(**{'sizeinbytes': 1, 'constant': 0x03}) 
1613          self.__field_cmd3.writetobuffer(buf) 
1614          self.__field_which.writetobuffer(buf) 
1615          self._bufferendoffset=buf.getcurrentoffset() 
1616          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 

1617   
1618   

1619 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 

1620          'Reads this packet from the supplied buffer' 
1621          self._bufferstartoffset=buf.getcurrentoffset() 
1622          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1623          self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x26}) 
1624          self.__field_cmd.readfrombuffer(buf) 
1625          self.__field_cmd2=UINT(**{'sizeinbytes': 1, 'constant': 0xf7}) 
1626          self.__field_cmd2.readfrombuffer(buf) 
1627          self.__field_cmd3=UINT(**{'sizeinbytes': 1, 'constant': 0x03}) 
1628          self.__field_cmd3.readfrombuffer(buf) 
1629          self.__field_which=UINT(**{'sizeinbytes': 1}) 
1630          self.__field_which.readfrombuffer(buf) 
1631          self._bufferendoffset=buf.getcurrentoffset() 

1632   
1633   

1634 -    def __getfield_cmd(self): 

1635          try: self.__field_cmd 
1636          except: 
1637              self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x26}) 
1638          return self.__field_cmd.getvalue() 

1639   

1640 -    def __setfield_cmd(self, value): 

1641          if isinstance(value,UINT): 
1642              self.__field_cmd=value 
1643          else: 
1644              self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'constant': 0x26}) 

1645   

1646 -    def __delfield_cmd(self): del self.__field_cmd 

1647   
1648      cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None) 
1649   

1650 -    def __getfield_cmd2(self): 

1651          try: self.__field_cmd2 
1652          except: 
1653              self.__field_cmd2=UINT(**{'sizeinbytes': 1, 'constant': 0xf7}) 
1654          return self.__field_cmd2.getvalue() 

1655   

1656 -    def __setfield_cmd2(self, value): 

1657          if isinstance(value,UINT): 
1658              self.__field_cmd2=value 
1659          else: 
1660              self.__field_cmd2=UINT(value,**{'sizeinbytes': 1, 'constant': 0xf7}) 

1661   

1662 -    def __delfield_cmd2(self): del self.__field_cmd2 

1663   
1664      cmd2=property(__getfield_cmd2, __setfield_cmd2, __delfield_cmd2, None) 
1665   

1666 -    def __getfield_cmd3(self): 

1667          try: self.__field_cmd3 
1668          except: 
1669              self.__field_cmd3=UINT(**{'sizeinbytes': 1, 'constant': 0x03}) 
1670          return self.__field_cmd3.getvalue() 

1671   

1672 -    def __setfield_cmd3(self, value): 

1673          if isinstance(value,UINT): 
1674              self.__field_cmd3=value 
1675          else: 
1676              self.__field_cmd3=UINT(value,**{'sizeinbytes': 1, 'constant': 0x03}) 

1677   

1678 -    def __delfield_cmd3(self): del self.__field_cmd3 

1679   
1680      cmd3=property(__getfield_cmd3, __setfield_cmd3, __delfield_cmd3, None) 
1681   

1682 -    def __getfield_which(self): 

1683          return self.__field_which.getvalue() 

1684   

1685 -    def __setfield_which(self, value): 

1686          if isinstance(value,UINT): 
1687              self.__field_which=value 
1688          else: 
1689              self.__field_which=UINT(value,**{'sizeinbytes': 1}) 

1690   

1691 -    def __delfield_which(self): del self.__field_which 

1692   
1693      which=property(__getfield_which, __setfield_which, __delfield_which, None) 
1694   

1695 -    def iscontainer(self): 

1696          return True 

1697   

1698 -    def containerelements(self): 

1699          yield ('cmd', self.__field_cmd, None) 
1700          yield ('cmd2', self.__field_cmd2, None) 
1701          yield ('cmd3', self.__field_cmd3, None) 
1702          yield ('which', self.__field_which, None) 

1703   
1704   
1705   
1706   

1707 -class dunnoresponse(BaseProtogenClass): 

1708      __fields=['stuff'] 
1709   

1710 -    def __init__(self, *args, **kwargs): 

1711          dict={} 
1712          # What was supplied to this function 
1713          dict.update(kwargs) 
1714          # Parent constructor 
1715          super(dunnoresponse,self).__init__(**dict) 
1716          if self.__class__ is dunnoresponse: 
1717              self._update(args,dict) 

1718   
1719   

1720 -    def getfields(self): 

1721          return self.__fields 

1722   
1723   

1724 -    def _update(self, args, kwargs): 

1725          super(dunnoresponse,self)._update(args,kwargs) 
1726          keys=kwargs.keys() 
1727          for key in keys: 
1728              if key in self.__fields: 
1729                  setattr(self, key, kwargs[key]) 
1730                  del kwargs[key] 
1731          # Were any unrecognized kwargs passed in? 
1732          if __debug__: 
1733              self._complainaboutunusedargs(dunnoresponse,kwargs) 
1734          if len(args): 
1735              dict2={} 
1736              dict2.update(kwargs) 
1737              kwargs=dict2 
1738              self.__field_stuff=DATA(*args,**dict2) 

1739          # Make all P fields that haven't already been constructed 
1740   
1741   

1742 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 

1743          'Writes this packet to the supplied buffer' 
1744          self._bufferstartoffset=buf.getcurrentoffset() 
1745          self.__field_stuff.writetobuffer(buf) 
1746          self._bufferendoffset=buf.getcurrentoffset() 
1747          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 

1748   
1749   

1750 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 

1751          'Reads this packet from the supplied buffer' 
1752          self._bufferstartoffset=buf.getcurrentoffset() 
1753          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1754          self.__field_stuff=DATA() 
1755          self.__field_stuff.readfrombuffer(buf) 
1756          self._bufferendoffset=buf.getcurrentoffset() 

1757   
1758   

1759 -    def __getfield_stuff(self): 

1760          return self.__field_stuff.getvalue() 

1761   

1762 -    def __setfield_stuff(self, value): 

1763          if isinstance(value,DATA): 
1764              self.__field_stuff=value 
1765          else: 
1766              self.__field_stuff=DATA(value,) 

1767   

1768 -    def __delfield_stuff(self): del self.__field_stuff 

1769   
1770      stuff=property(__getfield_stuff, __setfield_stuff, __delfield_stuff, None) 
1771   

1772 -    def iscontainer(self): 

1773          return True 

1774   

1775 -    def containerelements(self): 

1776          yield ('stuff', self.__field_stuff, None) 

1777   
1778   
1779   
1780   

1781 -class readlockcoderequest(BaseProtogenClass): 

1782      __fields=['cmd', 'cmd2', 'cmd3', 'padding'] 
1783   

1784 -    def __init__(self, *args, **kwargs): 

1785          dict={} 
1786          # What was supplied to this function 
1787          dict.update(kwargs) 
1788          # Parent constructor 
1789          super(readlockcoderequest,self).__init__(**dict) 
1790          if self.__class__ is readlockcoderequest: 
1791              self._update(args,dict) 

1792   
1793   

1794 -    def getfields(self): 

1795          return self.__fields 

1796   
1797   

1798 -    def _update(self, args, kwargs): 

1799          super(readlockcoderequest,self)._update(args,kwargs) 
1800          keys=kwargs.keys() 
1801          for key in keys: 
1802              if key in self.__fields: 
1803                  setattr(self, key, kwargs[key]) 
1804                  del kwargs[key] 
1805          # Were any unrecognized kwargs passed in? 
1806          if __debug__: 
1807              self._complainaboutunusedargs(readlockcoderequest,kwargs) 
1808          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 

1809          # Make all P fields that haven't already been constructed 
1810   
1811   

1812 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 

1813          'Writes this packet to the supplied buffer' 
1814          self._bufferstartoffset=buf.getcurrentoffset() 
1815          try: self.__field_cmd 
1816          except: 
1817              self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x26}) 
1818          self.__field_cmd.writetobuffer(buf) 
1819          try: self.__field_cmd2 
1820          except: 
1821              self.__field_cmd2=UINT(**{'sizeinbytes': 1, 'constant': 0x52}) 
1822          self.__field_cmd2.writetobuffer(buf) 
1823          try: self.__field_cmd3 
1824          except: 
1825              self.__field_cmd3=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 
1826          self.__field_cmd3.writetobuffer(buf) 
1827          try: self.__field_padding 
1828          except: 
1829              self.__field_padding=DATA(**{'sizeinbytes': 130}) 
1830          self.__field_padding.writetobuffer(buf) 
1831          self._bufferendoffset=buf.getcurrentoffset() 
1832          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 

1833   
1834   

1835 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 

1836          'Reads this packet from the supplied buffer' 
1837          self._bufferstartoffset=buf.getcurrentoffset() 
1838          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1839          self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x26}) 
1840          self.__field_cmd.readfrombuffer(buf) 
1841          self.__field_cmd2=UINT(**{'sizeinbytes': 1, 'constant': 0x52}) 
1842          self.__field_cmd2.readfrombuffer(buf) 
1843          self.__field_cmd3=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 
1844          self.__field_cmd3.readfrombuffer(buf) 
1845          self.__field_padding=DATA(**{'sizeinbytes': 130}) 
1846          self.__field_padding.readfrombuffer(buf) 
1847          self._bufferendoffset=buf.getcurrentoffset() 

1848   
1849   

1850 -    def __getfield_cmd(self): 

1851          try: self.__field_cmd 
1852          except: 
1853              self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x26}) 
1854          return self.__field_cmd.getvalue() 

1855   

1856 -    def __setfield_cmd(self, value): 

1857          if isinstance(value,UINT): 
1858              self.__field_cmd=value 
1859          else: 
1860              self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'constant': 0x26}) 

1861   

1862 -    def __delfield_cmd(self): del self.__field_cmd 

1863   
1864      cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None) 
1865   

1866 -    def __getfield_cmd2(self): 

1867          try: self.__field_cmd2 
1868          except: 
1869              self.__field_cmd2=UINT(**{'sizeinbytes': 1, 'constant': 0x52}) 
1870          return self.__field_cmd2.getvalue() 

1871   

1872 -    def __setfield_cmd2(self, value): 

1873          if isinstance(value,UINT): 
1874              self.__field_cmd2=value 
1875          else: 
1876              self.__field_cmd2=UINT(value,**{'sizeinbytes': 1, 'constant': 0x52}) 

1877   

1878 -    def __delfield_cmd2(self): del self.__field_cmd2 

1879   
1880      cmd2=property(__getfield_cmd2, __setfield_cmd2, __delfield_cmd2, None) 
1881   

1882 -    def __getfield_cmd3(self): 

1883          try: self.__field_cmd3 
1884          except: 
1885              self.__field_cmd3=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 
1886          return self.__field_cmd3.getvalue() 

1887   

1888 -    def __setfield_cmd3(self, value): 

1889          if isinstance(value,UINT): 
1890              self.__field_cmd3=value 
1891          else: 
1892              self.__field_cmd3=UINT(value,**{'sizeinbytes': 1, 'constant': 0x00}) 

1893   

1894 -    def __delfield_cmd3(self): del self.__field_cmd3 

1895   
1896      cmd3=property(__getfield_cmd3, __setfield_cmd3, __delfield_cmd3, None) 
1897   

1898 -    def __getfield_padding(self): 

1899          try: self.__field_padding 
1900          except: 
1901              self.__field_padding=DATA(**{'sizeinbytes': 130}) 
1902          return self.__field_padding.getvalue() 

1903   

1904 -    def __setfield_padding(self, value): 

1905          if isinstance(value,DATA): 
1906              self.__field_padding=value 
1907          else: 
1908              self.__field_padding=DATA(value,**{'sizeinbytes': 130}) 

1909   

1910 -    def __delfield_padding(self): del self.__field_padding 

1911   
1912      padding=property(__getfield_padding, __setfield_padding, __delfield_padding, None) 
1913   

1914 -    def iscontainer(self): 

1915          return True 

1916   

1917 -    def containerelements(self): 

1918          yield ('cmd', self.__field_cmd, None) 
1919          yield ('cmd2', self.__field_cmd2, None) 
1920          yield ('cmd3', self.__field_cmd3, None) 
1921          yield ('padding', self.__field_padding, None) 

1922   
1923   
1924   
1925   

1926 -class readlockcoderesponse(BaseProtogenClass): 

1927      __fields=['cmd', 'cmd2', 'cmd3', 'lockcode'] 
1928   

1929 -    def __init__(self, *args, **kwargs): 

1930          dict={} 
1931          # What was supplied to this function 
1932          dict.update(kwargs) 
1933          # Parent constructor 
1934          super(readlockcoderesponse,self).__init__(**dict) 
1935          if self.__class__ is readlockcoderesponse: 
1936              self._update(args,dict) 

1937   
1938   

1939 -    def getfields(self): 

1940          return self.__fields 

1941   
1942   

1943 -    def _update(self, args, kwargs): 

1944          super(readlockcoderesponse,self)._update(args,kwargs) 
1945          keys=kwargs.keys() 
1946          for key in keys: 
1947              if key in self.__fields: 
1948                  setattr(self, key, kwargs[key]) 
1949                  del kwargs[key] 
1950          # Were any unrecognized kwargs passed in? 
1951          if __debug__: 
1952              self._complainaboutunusedargs(readlockcoderesponse,kwargs) 
1953          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 

1954          # Make all P fields that haven't already been constructed 
1955   
1956   

1957 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 

1958          'Writes this packet to the supplied buffer' 
1959          self._bufferstartoffset=buf.getcurrentoffset() 
1960          self.__field_cmd.writetobuffer(buf) 
1961          self.__field_cmd2.writetobuffer(buf) 
1962          self.__field_cmd3.writetobuffer(buf) 
1963          self.__field_lockcode.writetobuffer(buf) 
1964          self._bufferendoffset=buf.getcurrentoffset() 
1965          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 

1966   
1967   

1968 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 

1969          'Reads this packet from the supplied buffer' 
1970          self._bufferstartoffset=buf.getcurrentoffset() 
1971          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1972          self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x26}) 
1973          self.__field_cmd.readfrombuffer(buf) 
1974          self.__field_cmd2=UINT(**{'sizeinbytes': 1, 'constant': 0x52}) 
1975          self.__field_cmd2.readfrombuffer(buf) 
1976          self.__field_cmd3=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 
1977          self.__field_cmd3.readfrombuffer(buf) 
1978          self.__field_lockcode=USTRING() 
1979          self.__field_lockcode.readfrombuffer(buf) 
1980          self._bufferendoffset=buf.getcurrentoffset() 

1981   
1982   

1983 -    def __getfield_cmd(self): 

1984          return self.__field_cmd.getvalue() 

1985   

1986 -    def __setfield_cmd(self, value): 

1987          if isinstance(value,UINT): 
1988              self.__field_cmd=value 
1989          else: 
1990              self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'constant': 0x26}) 

1991   

1992 -    def __delfield_cmd(self): del self.__field_cmd 

1993   
1994      cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None) 
1995   

1996 -    def __getfield_cmd2(self): 

1997          return self.__field_cmd2.getvalue() 

1998   

1999 -    def __setfield_cmd2(self, value): 

2000          if isinstance(value,UINT): 
2001              self.__field_cmd2=value 
2002          else: 
2003              self.__field_cmd2=UINT(value,**{'sizeinbytes': 1, 'constant': 0x52}) 

2004   

2005 -    def __delfield_cmd2(self): del self.__field_cmd2 

2006   
2007      cmd2=property(__getfield_cmd2, __setfield_cmd2, __delfield_cmd2, None) 
2008   

2009 -    def __getfield_cmd3(self): 

2010          return self.__field_cmd3.getvalue() 

2011   

2012 -    def __setfield_cmd3(self, value): 

2013          if isinstance(value,UINT): 
2014              self.__field_cmd3=value 
2015          else: 
2016              self.__field_cmd3=UINT(value,**{'sizeinbytes': 1, 'constant': 0x00}) 

2017   

2018 -    def __delfield_cmd3(self): del self.__field_cmd3 

2019   
2020      cmd3=property(__getfield_cmd3, __setfield_cmd3, __delfield_cmd3, None) 
2021   

2022 -    def __getfield_lockcode(self): 

2023          return self.__field_lockcode.getvalue() 

2024   

2025 -    def __setfield_lockcode(self, value): 

2026          if isinstance(value,USTRING): 
2027              self.__field_lockcode=value 
2028          else: 
2029              self.__field_lockcode=USTRING(value,) 

2030   

2031 -    def __delfield_lockcode(self): del self.__field_lockcode 

2032   
2033      lockcode=property(__getfield_lockcode, __setfield_lockcode, __delfield_lockcode, None) 
2034   

2035 -    def iscontainer(self): 

2036          return True 

2037   

2038 -    def containerelements(self): 

2039          yield ('cmd', self.__field_cmd, None) 
2040          yield ('cmd2', self.__field_cmd2, None) 
2041          yield ('cmd3', self.__field_cmd3, None) 
2042          yield ('lockcode', self.__field_lockcode, None) 

2043

   Trees       Indices       Help   
bitpim
Generated by Epydoc 3.0.1 on Sun Jan 24 16:23:33 2010 http://epydoc.sourceforge.net