Source Code for Module phones.p_sanyo7050

   1  # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE 
   2   
   3  """Various descriptions of data specific to Sanyo SCP-7050""" 
   4   
   5  from prototypes import * 
   6   
   7  # Make all sanyo stuff available in this module as well 
   8  from p_sanyo import * 
   9  from p_sanyomedia import * 
  10  from p_sanyonewer import * 
  11  from p_sanyo4930 import * 
  12  from p_sanyo6600 import * 
  13   
  14  # We use LSB for all integer like fields 
  15  UINT=UINTlsb 
  16  BOOL=BOOLlsb 
  17  NUMPHONEBOOKENTRIES=500 
  18  MAXNUMBERS=700 
  19  MAXEMAILS=1000 
  20  MAXURLS=500 
  21  MAXMEMOS=500 
  22  MAXADDRESSES=500 
  23  _NUMSPEEDDIALS=8 
  24  _NUMLONGNUMBERS=5 
  25  _LONGPHONENUMBERLEN=30 
  26  _NUMEVENTSLOTS=100 
  27  _NUMCALLALARMSLOTS=15 
  28   # Need to check.  Is max phone will hold 32/96 or 33/97 
  29  MAXNUMBERLEN=48 
  30  MAXEMAILLEN=96 
  31  MAXURLLEN=96 
  32  MAXMEMOLEN=96 
  33  HASRINGPICBUF=0 
  34  NUMGROUPS=20 
  35  NUMPHONENUMBERS=7 
  36  NUMEMAILS=2 
  37  FIRSTSPEEDDIAL=2 
  38  LASTSPEEDDIAL=9 
  39   
  40   
  41 -class bufferpartrequest(BaseProtogenClass): 
  42      __fields=['bufpartsize', 'header', 'pad'] 
  43   
  44 -    def __init__(self, *args, **kwargs): 
  45          dict={} 
  46          # What was supplied to this function 
  47          dict.update(kwargs) 
  48          # Parent constructor 
  49          super(bufferpartrequest,self).__init__(**dict) 
  50          if self.__class__ is bufferpartrequest: 
  51              self._update(args,dict) 
  52   
  53   
  54 -    def getfields(self): 
  55          return self.__fields 
  56   
  57   
  58 -    def _update(self, args, kwargs): 
  59          super(bufferpartrequest,self)._update(args,kwargs) 
  60          keys=kwargs.keys() 
  61          for key in keys: 
  62              if key in self.__fields: 
  63                  setattr(self, key, kwargs[key]) 
  64                  del kwargs[key] 
  65          # Were any unrecognized kwargs passed in? 
  66          if __debug__: 
  67              self._complainaboutunusedargs(bufferpartrequest,kwargs) 
  68          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
  69          # Make all P fields that haven't already been constructed 
  70          try: self.__field_bufpartsize 
  71          except: 
  72              self.__field_bufpartsize=UINT(**{'constant': 1024}) 
  73   
  74   
  75 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
  76          'Writes this packet to the supplied buffer' 
  77          self._bufferstartoffset=buf.getcurrentoffset() 
  78          try: self.__field_header 
  79          except: 
  80              self.__field_header=sanyoheader(**{'packettype': 0xc7}) 
  81          self.__field_header.writetobuffer(buf) 
  82          try: self.__field_pad 
  83          except: 
  84              self.__field_pad=UNKNOWN(**{'sizeinbytes': 1026}) 
  85          self.__field_pad.writetobuffer(buf) 
  86          self._bufferendoffset=buf.getcurrentoffset() 
  87          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
  88   
  89   
  90 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
  91          'Reads this packet from the supplied buffer' 
  92          self._bufferstartoffset=buf.getcurrentoffset() 
  93          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
  94          self.__field_header=sanyoheader(**{'packettype': 0xc7}) 
  95          self.__field_header.readfrombuffer(buf) 
  96          self.__field_pad=UNKNOWN(**{'sizeinbytes': 1026}) 
  97          self.__field_pad.readfrombuffer(buf) 
  98          self._bufferendoffset=buf.getcurrentoffset() 
  99   
 100   
 101 -    def __getfield_bufpartsize(self): 
 102          return self.__field_bufpartsize.getvalue() 
 103   
 104 -    def __setfield_bufpartsize(self, value): 
 105          if isinstance(value,UINT): 
 106              self.__field_bufpartsize=value 
 107          else: 
 108              self.__field_bufpartsize=UINT(value,**{'constant': 1024}) 
 109   
 110 -    def __delfield_bufpartsize(self): del self.__field_bufpartsize 
 111   
 112      bufpartsize=property(__getfield_bufpartsize, __setfield_bufpartsize, __delfield_bufpartsize, None) 
 113   
 114 -    def __getfield_header(self): 
 115          try: self.__field_header 
 116          except: 
 117              self.__field_header=sanyoheader(**{'packettype': 0xc7}) 
 118          return self.__field_header.getvalue() 
 119   
 120 -    def __setfield_header(self, value): 
 121          if isinstance(value,sanyoheader): 
 122              self.__field_header=value 
 123          else: 
 124              self.__field_header=sanyoheader(value,**{'packettype': 0xc7}) 
 125   
 126 -    def __delfield_header(self): del self.__field_header 
 127   
 128      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
 129   
 130 -    def __getfield_pad(self): 
 131          try: self.__field_pad 
 132          except: 
 133              self.__field_pad=UNKNOWN(**{'sizeinbytes': 1026}) 
 134          return self.__field_pad.getvalue() 
 135   
 136 -    def __setfield_pad(self, value): 
 137          if isinstance(value,UNKNOWN): 
 138              self.__field_pad=value 
 139          else: 
 140              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 1026}) 
 141   
 142 -    def __delfield_pad(self): del self.__field_pad 
 143   
 144      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
 145   
 146 -    def iscontainer(self): 
 147          return True 
 148   
 149 -    def containerelements(self): 
 150          yield ('bufpartsize', self.__field_bufpartsize, None) 
 151          yield ('header', self.__field_header, None) 
 152          yield ('pad', self.__field_pad, None) 
 153   
 154   
 155   
 156   
 157 -class bufferpartupdaterequest(BaseProtogenClass): 
 158      __fields=['bufpartsize', 'header', 'data', 'pad'] 
 159   
 160 -    def __init__(self, *args, **kwargs): 
 161          dict={} 
 162          # What was supplied to this function 
 163          dict.update(kwargs) 
 164          # Parent constructor 
 165          super(bufferpartupdaterequest,self).__init__(**dict) 
 166          if self.__class__ is bufferpartupdaterequest: 
 167              self._update(args,dict) 
 168   
 169   
 170 -    def getfields(self): 
 171          return self.__fields 
 172   
 173   
 174 -    def _update(self, args, kwargs): 
 175          super(bufferpartupdaterequest,self)._update(args,kwargs) 
 176          keys=kwargs.keys() 
 177          for key in keys: 
 178              if key in self.__fields: 
 179                  setattr(self, key, kwargs[key]) 
 180                  del kwargs[key] 
 181          # Were any unrecognized kwargs passed in? 
 182          if __debug__: 
 183              self._complainaboutunusedargs(bufferpartupdaterequest,kwargs) 
 184          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 185          # Make all P fields that haven't already been constructed 
 186          try: self.__field_bufpartsize 
 187          except: 
 188              self.__field_bufpartsize=UINT(**{'constant': 1024}) 
 189   
 190   
 191 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 192          'Writes this packet to the supplied buffer' 
 193          self._bufferstartoffset=buf.getcurrentoffset() 
 194          try: self.__field_header 
 195          except: 
 196              self.__field_header=sanyowriteheader(**{'packettype': 0xc7}) 
 197          self.__field_header.writetobuffer(buf) 
 198          self.__field_data.writetobuffer(buf) 
 199          try: self.__field_pad 
 200          except: 
 201              self.__field_pad=UNKNOWN(**{'sizeinbytes': 2}) 
 202          self.__field_pad.writetobuffer(buf) 
 203          self._bufferendoffset=buf.getcurrentoffset() 
 204          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 205   
 206   
 207 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 208          'Reads this packet from the supplied buffer' 
 209          self._bufferstartoffset=buf.getcurrentoffset() 
 210          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 211          self.__field_header=sanyowriteheader(**{'packettype': 0xc7}) 
 212          self.__field_header.readfrombuffer(buf) 
 213          self.__field_data=DATA(**{'sizeinbytes': self.bufpartsize}) 
 214          self.__field_data.readfrombuffer(buf) 
 215          self.__field_pad=UNKNOWN(**{'sizeinbytes': 2}) 
 216          self.__field_pad.readfrombuffer(buf) 
 217          self._bufferendoffset=buf.getcurrentoffset() 
 218   
 219   
 220 -    def __getfield_bufpartsize(self): 
 221          return self.__field_bufpartsize.getvalue() 
 222   
 223 -    def __setfield_bufpartsize(self, value): 
 224          if isinstance(value,UINT): 
 225              self.__field_bufpartsize=value 
 226          else: 
 227              self.__field_bufpartsize=UINT(value,**{'constant': 1024}) 
 228   
 229 -    def __delfield_bufpartsize(self): del self.__field_bufpartsize 
 230   
 231      bufpartsize=property(__getfield_bufpartsize, __setfield_bufpartsize, __delfield_bufpartsize, None) 
 232   
 233 -    def __getfield_header(self): 
 234          try: self.__field_header 
 235          except: 
 236              self.__field_header=sanyowriteheader(**{'packettype': 0xc7}) 
 237          return self.__field_header.getvalue() 
 238   
 239 -    def __setfield_header(self, value): 
 240          if isinstance(value,sanyowriteheader): 
 241              self.__field_header=value 
 242          else: 
 243              self.__field_header=sanyowriteheader(value,**{'packettype': 0xc7}) 
 244   
 245 -    def __delfield_header(self): del self.__field_header 
 246   
 247      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
 248   
 249 -    def __getfield_data(self): 
 250          return self.__field_data.getvalue() 
 251   
 252 -    def __setfield_data(self, value): 
 253          if isinstance(value,DATA): 
 254              self.__field_data=value 
 255          else: 
 256              self.__field_data=DATA(value,**{'sizeinbytes': self.bufpartsize}) 
 257   
 258 -    def __delfield_data(self): del self.__field_data 
 259   
 260      data=property(__getfield_data, __setfield_data, __delfield_data, None) 
 261   
 262 -    def __getfield_pad(self): 
 263          try: self.__field_pad 
 264          except: 
 265              self.__field_pad=UNKNOWN(**{'sizeinbytes': 2}) 
 266          return self.__field_pad.getvalue() 
 267   
 268 -    def __setfield_pad(self, value): 
 269          if isinstance(value,UNKNOWN): 
 270              self.__field_pad=value 
 271          else: 
 272              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 2}) 
 273   
 274 -    def __delfield_pad(self): del self.__field_pad 
 275   
 276      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
 277   
 278 -    def iscontainer(self): 
 279          return True 
 280   
 281 -    def containerelements(self): 
 282          yield ('bufpartsize', self.__field_bufpartsize, None) 
 283          yield ('header', self.__field_header, None) 
 284          yield ('data', self.__field_data, None) 
 285          yield ('pad', self.__field_pad, None) 
 286   
 287   
 288   
 289   
 290 -class pbsortbuffer(BaseProtogenClass): 
 291      "Various arrays for sorting the phone book, speed dial, determining which" 
 292      __fields=['startcommand', 'bufsize', 'comment', 'groupslotsused', 'pad', 'groupslotusedflags', 'slotsused', 'usedflags', 'speeddialindex', 'nameslotsused', 'nameusedflags', 'sortorder', 'pbfirstletters', 'numslotsused', 'numusedflags', 'emailslotsused', 'emailusedflags', 'urlslotsused', 'urlusedflags', 'num_address', 'addressusedflags', 'num_memo', 'memousedflags', 'junk'] 
 293   
 294 -    def __init__(self, *args, **kwargs): 
 295          dict={} 
 296          # What was supplied to this function 
 297          dict.update(kwargs) 
 298          # Parent constructor 
 299          super(pbsortbuffer,self).__init__(**dict) 
 300          if self.__class__ is pbsortbuffer: 
 301              self._update(args,dict) 
 302   
 303   
 304 -    def getfields(self): 
 305          return self.__fields 
 306   
 307   
 308 -    def _update(self, args, kwargs): 
 309          super(pbsortbuffer,self)._update(args,kwargs) 
 310          keys=kwargs.keys() 
 311          for key in keys: 
 312              if key in self.__fields: 
 313                  setattr(self, key, kwargs[key]) 
 314                  del kwargs[key] 
 315          # Were any unrecognized kwargs passed in? 
 316          if __debug__: 
 317              self._complainaboutunusedargs(pbsortbuffer,kwargs) 
 318          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 319          # Make all P fields that haven't already been constructed 
 320          try: self.__field_startcommand 
 321          except: 
 322              self.__field_startcommand=UINT(**{'constant': 0x0e}) 
 323          try: self.__field_bufsize 
 324          except: 
 325              self.__field_bufsize=UINT(**{'constant': 6144}) 
 326          try: self.__field_comment 
 327          except: 
 328              self.__field_comment=USTRING(**{'default': "sort buffer"}) 
 329   
 330   
 331 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 332          'Writes this packet to the supplied buffer' 
 333          self._bufferstartoffset=buf.getcurrentoffset() 
 334          self.__field_groupslotsused.writetobuffer(buf) 
 335          try: self.__field_pad 
 336          except: 
 337              self.__field_pad=UNKNOWN(**{'sizeinbytes': 2}) 
 338          self.__field_pad.writetobuffer(buf) 
 339          try: self.__field_groupslotusedflags 
 340          except: 
 341              self.__field_groupslotusedflags=LIST(**{'elementclass': _gen_p_sanyo7050_79, 'length': NUMGROUPS, 'createdefault': True}) 
 342          self.__field_groupslotusedflags.writetobuffer(buf) 
 343          self.__field_slotsused.writetobuffer(buf) 
 344          try: self.__field_usedflags 
 345          except: 
 346              self.__field_usedflags=LIST(**{'elementclass': _gen_p_sanyo7050_83, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 
 347          self.__field_usedflags.writetobuffer(buf) 
 348          try: self.__field_speeddialindex 
 349          except: 
 350              self.__field_speeddialindex=LIST(**{'elementclass': _gen_p_sanyo7050_85, 'length': _NUMSPEEDDIALS}) 
 351          self.__field_speeddialindex.writetobuffer(buf) 
 352          self.__field_nameslotsused.writetobuffer(buf) 
 353          try: self.__field_nameusedflags 
 354          except: 
 355              self.__field_nameusedflags=LIST(**{'elementclass': _gen_p_sanyo7050_89, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 
 356          self.__field_nameusedflags.writetobuffer(buf) 
 357          try: self.__field_sortorder 
 358          except: 
 359              self.__field_sortorder=LIST(**{'elementclass': _gen_p_sanyo7050_91, 'length': NUMPHONEBOOKENTRIES}) 
 360          self.__field_sortorder.writetobuffer(buf) 
 361          self.__field_pbfirstletters.writetobuffer(buf) 
 362          self.__field_numslotsused.writetobuffer(buf) 
 363          try: self.__field_numusedflags 
 364          except: 
 365              self.__field_numusedflags=LIST(**{'elementclass': _gen_p_sanyo7050_96, 'length': MAXNUMBERS, 'createdefault': True}) 
 366          self.__field_numusedflags.writetobuffer(buf) 
 367          self.__field_emailslotsused.writetobuffer(buf) 
 368          try: self.__field_emailusedflags 
 369          except: 
 370              self.__field_emailusedflags=LIST(**{'elementclass': _gen_p_sanyo7050_100, 'length': MAXEMAILS, 'createdefault': True}) 
 371          self.__field_emailusedflags.writetobuffer(buf) 
 372          self.__field_urlslotsused.writetobuffer(buf) 
 373          try: self.__field_urlusedflags 
 374          except: 
 375              self.__field_urlusedflags=LIST(**{'elementclass': _gen_p_sanyo7050_103, 'length': MAXURLS, 'createdefault': True}) 
 376          self.__field_urlusedflags.writetobuffer(buf) 
 377          self.__field_num_address.writetobuffer(buf) 
 378          try: self.__field_addressusedflags 
 379          except: 
 380              self.__field_addressusedflags=LIST(**{'elementclass': _gen_p_sanyo7050_107, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 
 381          self.__field_addressusedflags.writetobuffer(buf) 
 382          self.__field_num_memo.writetobuffer(buf) 
 383          try: self.__field_memousedflags 
 384          except: 
 385              self.__field_memousedflags=LIST(**{'elementclass': _gen_p_sanyo7050_111, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 
 386          self.__field_memousedflags.writetobuffer(buf) 
 387          try: self.__field_junk 
 388          except: 
 389              self.__field_junk=UNKNOWN(**{'sizeinbytes': 391}) 
 390          self.__field_junk.writetobuffer(buf) 
 391          self._bufferendoffset=buf.getcurrentoffset() 
 392          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 393   
 394   
 395 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 396          'Reads this packet from the supplied buffer' 
 397          self._bufferstartoffset=buf.getcurrentoffset() 
 398          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 399          self.__field_groupslotsused=UINT(**{'sizeinbytes': 1}) 
 400          self.__field_groupslotsused.readfrombuffer(buf) 
 401          self.__field_pad=UNKNOWN(**{'sizeinbytes': 2}) 
 402          self.__field_pad.readfrombuffer(buf) 
 403          self.__field_groupslotusedflags=LIST(**{'elementclass': _gen_p_sanyo7050_79, 'length': NUMGROUPS, 'createdefault': True}) 
 404          self.__field_groupslotusedflags.readfrombuffer(buf) 
 405          self.__field_slotsused=UINT(**{'sizeinbytes': 2}) 
 406          self.__field_slotsused.readfrombuffer(buf) 
 407          self.__field_usedflags=LIST(**{'elementclass': _gen_p_sanyo7050_83, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 
 408          self.__field_usedflags.readfrombuffer(buf) 
 409          self.__field_speeddialindex=LIST(**{'elementclass': _gen_p_sanyo7050_85, 'length': _NUMSPEEDDIALS}) 
 410          self.__field_speeddialindex.readfrombuffer(buf) 
 411          self.__field_nameslotsused=UINT(**{'sizeinbytes': 2}) 
 412          self.__field_nameslotsused.readfrombuffer(buf) 
 413          self.__field_nameusedflags=LIST(**{'elementclass': _gen_p_sanyo7050_89, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 
 414          self.__field_nameusedflags.readfrombuffer(buf) 
 415          self.__field_sortorder=LIST(**{'elementclass': _gen_p_sanyo7050_91, 'length': NUMPHONEBOOKENTRIES}) 
 416          self.__field_sortorder.readfrombuffer(buf) 
 417          self.__field_pbfirstletters=USTRING(**{'terminator': None, 'sizeinbytes': NUMPHONEBOOKENTRIES}) 
 418          self.__field_pbfirstletters.readfrombuffer(buf) 
 419          self.__field_numslotsused=UINT(**{'sizeinbytes': 2}) 
 420          self.__field_numslotsused.readfrombuffer(buf) 
 421          self.__field_numusedflags=LIST(**{'elementclass': _gen_p_sanyo7050_96, 'length': MAXNUMBERS, 'createdefault': True}) 
 422          self.__field_numusedflags.readfrombuffer(buf) 
 423          self.__field_emailslotsused=UINT(**{'sizeinbytes': 2}) 
 424          self.__field_emailslotsused.readfrombuffer(buf) 
 425          self.__field_emailusedflags=LIST(**{'elementclass': _gen_p_sanyo7050_100, 'length': MAXEMAILS, 'createdefault': True}) 
 426          self.__field_emailusedflags.readfrombuffer(buf) 
 427          self.__field_urlslotsused=UINT(**{'sizeinbytes': 2}) 
 428          self.__field_urlslotsused.readfrombuffer(buf) 
 429          self.__field_urlusedflags=LIST(**{'elementclass': _gen_p_sanyo7050_103, 'length': MAXURLS, 'createdefault': True}) 
 430          self.__field_urlusedflags.readfrombuffer(buf) 
 431          self.__field_num_address=UINT(**{'sizeinbytes': 2}) 
 432          self.__field_num_address.readfrombuffer(buf) 
 433          self.__field_addressusedflags=LIST(**{'elementclass': _gen_p_sanyo7050_107, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 
 434          self.__field_addressusedflags.readfrombuffer(buf) 
 435          self.__field_num_memo=UINT(**{'sizeinbytes': 2}) 
 436          self.__field_num_memo.readfrombuffer(buf) 
 437          self.__field_memousedflags=LIST(**{'elementclass': _gen_p_sanyo7050_111, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 
 438          self.__field_memousedflags.readfrombuffer(buf) 
 439          self.__field_junk=UNKNOWN(**{'sizeinbytes': 391}) 
 440          self.__field_junk.readfrombuffer(buf) 
 441          self._bufferendoffset=buf.getcurrentoffset() 
 442   
 443   
 444 -    def __getfield_startcommand(self): 
 445          return self.__field_startcommand.getvalue() 
 446   
 447 -    def __setfield_startcommand(self, value): 
 448          if isinstance(value,UINT): 
 449              self.__field_startcommand=value 
 450          else: 
 451              self.__field_startcommand=UINT(value,**{'constant': 0x0e}) 
 452   
 453 -    def __delfield_startcommand(self): del self.__field_startcommand 
 454   
 455      startcommand=property(__getfield_startcommand, __setfield_startcommand, __delfield_startcommand, "Starting command for R/W buf parts") 
 456   
 457 -    def __getfield_bufsize(self): 
 458          return self.__field_bufsize.getvalue() 
 459   
 460 -    def __setfield_bufsize(self, value): 
 461          if isinstance(value,UINT): 
 462              self.__field_bufsize=value 
 463          else: 
 464              self.__field_bufsize=UINT(value,**{'constant': 6144}) 
 465   
 466 -    def __delfield_bufsize(self): del self.__field_bufsize 
 467   
 468      bufsize=property(__getfield_bufsize, __setfield_bufsize, __delfield_bufsize, None) 
 469   
 470 -    def __getfield_comment(self): 
 471          try: self.__field_comment 
 472          except: 
 473              self.__field_comment=USTRING(**{'default': "sort buffer"}) 
 474          return self.__field_comment.getvalue() 
 475   
 476 -    def __setfield_comment(self, value): 
 477          if isinstance(value,USTRING): 
 478              self.__field_comment=value 
 479          else: 
 480              self.__field_comment=USTRING(value,**{'default': "sort buffer"}) 
 481   
 482 -    def __delfield_comment(self): del self.__field_comment 
 483   
 484      comment=property(__getfield_comment, __setfield_comment, __delfield_comment, None) 
 485   
 486 -    def __getfield_groupslotsused(self): 
 487          return self.__field_groupslotsused.getvalue() 
 488   
 489 -    def __setfield_groupslotsused(self, value): 
 490          if isinstance(value,UINT): 
 491              self.__field_groupslotsused=value 
 492          else: 
 493              self.__field_groupslotsused=UINT(value,**{'sizeinbytes': 1}) 
 494   
 495 -    def __delfield_groupslotsused(self): del self.__field_groupslotsused 
 496   
 497      groupslotsused=property(__getfield_groupslotsused, __setfield_groupslotsused, __delfield_groupslotsused, None) 
 498   
 499 -    def __getfield_pad(self): 
 500          try: self.__field_pad 
 501          except: 
 502              self.__field_pad=UNKNOWN(**{'sizeinbytes': 2}) 
 503          return self.__field_pad.getvalue() 
 504   
 505 -    def __setfield_pad(self, value): 
 506          if isinstance(value,UNKNOWN): 
 507              self.__field_pad=value 
 508          else: 
 509              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 2}) 
 510   
 511 -    def __delfield_pad(self): del self.__field_pad 
 512   
 513      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
 514   
 515 -    def __getfield_groupslotusedflags(self): 
 516          try: self.__field_groupslotusedflags 
 517          except: 
 518              self.__field_groupslotusedflags=LIST(**{'elementclass': _gen_p_sanyo7050_79, 'length': NUMGROUPS, 'createdefault': True}) 
 519          return self.__field_groupslotusedflags.getvalue() 
 520   
 521 -    def __setfield_groupslotusedflags(self, value): 
 522          if isinstance(value,LIST): 
 523              self.__field_groupslotusedflags=value 
 524          else: 
 525              self.__field_groupslotusedflags=LIST(value,**{'elementclass': _gen_p_sanyo7050_79, 'length': NUMGROUPS, 'createdefault': True}) 
 526   
 527 -    def __delfield_groupslotusedflags(self): del self.__field_groupslotusedflags 
 528   
 529      groupslotusedflags=property(__getfield_groupslotusedflags, __setfield_groupslotusedflags, __delfield_groupslotusedflags, None) 
 530   
 531 -    def __getfield_slotsused(self): 
 532          return self.__field_slotsused.getvalue() 
 533   
 534 -    def __setfield_slotsused(self, value): 
 535          if isinstance(value,UINT): 
 536              self.__field_slotsused=value 
 537          else: 
 538              self.__field_slotsused=UINT(value,**{'sizeinbytes': 2}) 
 539   
 540 -    def __delfield_slotsused(self): del self.__field_slotsused 
 541   
 542      slotsused=property(__getfield_slotsused, __setfield_slotsused, __delfield_slotsused, None) 
 543   
 544 -    def __getfield_usedflags(self): 
 545          try: self.__field_usedflags 
 546          except: 
 547              self.__field_usedflags=LIST(**{'elementclass': _gen_p_sanyo7050_83, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 
 548          return self.__field_usedflags.getvalue() 
 549   
 550 -    def __setfield_usedflags(self, value): 
 551          if isinstance(value,LIST): 
 552              self.__field_usedflags=value 
 553          else: 
 554              self.__field_usedflags=LIST(value,**{'elementclass': _gen_p_sanyo7050_83, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 
 555   
 556 -    def __delfield_usedflags(self): del self.__field_usedflags 
 557   
 558      usedflags=property(__getfield_usedflags, __setfield_usedflags, __delfield_usedflags, None) 
 559   
 560 -    def __getfield_speeddialindex(self): 
 561          try: self.__field_speeddialindex 
 562          except: 
 563              self.__field_speeddialindex=LIST(**{'elementclass': _gen_p_sanyo7050_85, 'length': _NUMSPEEDDIALS}) 
 564          return self.__field_speeddialindex.getvalue() 
 565   
 566 -    def __setfield_speeddialindex(self, value): 
 567          if isinstance(value,LIST): 
 568              self.__field_speeddialindex=value 
 569          else: 
 570              self.__field_speeddialindex=LIST(value,**{'elementclass': _gen_p_sanyo7050_85, 'length': _NUMSPEEDDIALS}) 
 571   
 572 -    def __delfield_speeddialindex(self): del self.__field_speeddialindex 
 573   
 574      speeddialindex=property(__getfield_speeddialindex, __setfield_speeddialindex, __delfield_speeddialindex, None) 
 575   
 576 -    def __getfield_nameslotsused(self): 
 577          return self.__field_nameslotsused.getvalue() 
 578   
 579 -    def __setfield_nameslotsused(self, value): 
 580          if isinstance(value,UINT): 
 581              self.__field_nameslotsused=value 
 582          else: 
 583              self.__field_nameslotsused=UINT(value,**{'sizeinbytes': 2}) 
 584   
 585 -    def __delfield_nameslotsused(self): del self.__field_nameslotsused 
 586   
 587      nameslotsused=property(__getfield_nameslotsused, __setfield_nameslotsused, __delfield_nameslotsused, "Always seems to be the same.  Why duplicated?") 
 588   
 589 -    def __getfield_nameusedflags(self): 
 590          try: self.__field_nameusedflags 
 591          except: 
 592              self.__field_nameusedflags=LIST(**{'elementclass': _gen_p_sanyo7050_89, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 
 593          return self.__field_nameusedflags.getvalue() 
 594   
 595 -    def __setfield_nameusedflags(self, value): 
 596          if isinstance(value,LIST): 
 597              self.__field_nameusedflags=value 
 598          else: 
 599              self.__field_nameusedflags=LIST(value,**{'elementclass': _gen_p_sanyo7050_89, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 
 600   
 601 -    def __delfield_nameusedflags(self): del self.__field_nameusedflags 
 602   
 603      nameusedflags=property(__getfield_nameusedflags, __setfield_nameusedflags, __delfield_nameusedflags, None) 
 604   
 605 -    def __getfield_sortorder(self): 
 606          try: self.__field_sortorder 
 607          except: 
 608              self.__field_sortorder=LIST(**{'elementclass': _gen_p_sanyo7050_91, 'length': NUMPHONEBOOKENTRIES}) 
 609          return self.__field_sortorder.getvalue() 
 610   
 611 -    def __setfield_sortorder(self, value): 
 612          if isinstance(value,LIST): 
 613              self.__field_sortorder=value 
 614          else: 
 615              self.__field_sortorder=LIST(value,**{'elementclass': _gen_p_sanyo7050_91, 'length': NUMPHONEBOOKENTRIES}) 
 616   
 617 -    def __delfield_sortorder(self): del self.__field_sortorder 
 618   
 619      sortorder=property(__getfield_sortorder, __setfield_sortorder, __delfield_sortorder, None) 
 620   
 621 -    def __getfield_pbfirstletters(self): 
 622          return self.__field_pbfirstletters.getvalue() 
 623   
 624 -    def __setfield_pbfirstletters(self, value): 
 625          if isinstance(value,USTRING): 
 626              self.__field_pbfirstletters=value 
 627          else: 
 628              self.__field_pbfirstletters=USTRING(value,**{'terminator': None, 'sizeinbytes': NUMPHONEBOOKENTRIES}) 
 629   
 630 -    def __delfield_pbfirstletters(self): del self.__field_pbfirstletters 
 631   
 632      pbfirstletters=property(__getfield_pbfirstletters, __setfield_pbfirstletters, __delfield_pbfirstletters, None) 
 633   
 634 -    def __getfield_numslotsused(self): 
 635          return self.__field_numslotsused.getvalue() 
 636   
 637 -    def __setfield_numslotsused(self, value): 
 638          if isinstance(value,UINT): 
 639              self.__field_numslotsused=value 
 640          else: 
 641              self.__field_numslotsused=UINT(value,**{'sizeinbytes': 2}) 
 642   
 643 -    def __delfield_numslotsused(self): del self.__field_numslotsused 
 644   
 645      numslotsused=property(__getfield_numslotsused, __setfield_numslotsused, __delfield_numslotsused, "Number of phone number slots used") 
 646   
 647 -    def __getfield_numusedflags(self): 
 648          try: self.__field_numusedflags 
 649          except: 
 650              self.__field_numusedflags=LIST(**{'elementclass': _gen_p_sanyo7050_96, 'length': MAXNUMBERS, 'createdefault': True}) 
 651          return self.__field_numusedflags.getvalue() 
 652   
 653 -    def __setfield_numusedflags(self, value): 
 654          if isinstance(value,LIST): 
 655              self.__field_numusedflags=value 
 656          else: 
 657              self.__field_numusedflags=LIST(value,**{'elementclass': _gen_p_sanyo7050_96, 'length': MAXNUMBERS, 'createdefault': True}) 
 658   
 659 -    def __delfield_numusedflags(self): del self.__field_numusedflags 
 660   
 661      numusedflags=property(__getfield_numusedflags, __setfield_numusedflags, __delfield_numusedflags, None) 
 662   
 663 -    def __getfield_emailslotsused(self): 
 664          return self.__field_emailslotsused.getvalue() 
 665   
 666 -    def __setfield_emailslotsused(self, value): 
 667          if isinstance(value,UINT): 
 668              self.__field_emailslotsused=value 
 669          else: 
 670              self.__field_emailslotsused=UINT(value,**{'sizeinbytes': 2}) 
 671   
 672 -    def __delfield_emailslotsused(self): del self.__field_emailslotsused 
 673   
 674      emailslotsused=property(__getfield_emailslotsused, __setfield_emailslotsused, __delfield_emailslotsused, None) 
 675   
 676 -    def __getfield_emailusedflags(self): 
 677          try: self.__field_emailusedflags 
 678          except: 
 679              self.__field_emailusedflags=LIST(**{'elementclass': _gen_p_sanyo7050_100, 'length': MAXEMAILS, 'createdefault': True}) 
 680          return self.__field_emailusedflags.getvalue() 
 681   
 682 -    def __setfield_emailusedflags(self, value): 
 683          if isinstance(value,LIST): 
 684              self.__field_emailusedflags=value 
 685          else: 
 686              self.__field_emailusedflags=LIST(value,**{'elementclass': _gen_p_sanyo7050_100, 'length': MAXEMAILS, 'createdefault': True}) 
 687   
 688 -    def __delfield_emailusedflags(self): del self.__field_emailusedflags 
 689   
 690      emailusedflags=property(__getfield_emailusedflags, __setfield_emailusedflags, __delfield_emailusedflags, None) 
 691   
 692 -    def __getfield_urlslotsused(self): 
 693          return self.__field_urlslotsused.getvalue() 
 694   
 695 -    def __setfield_urlslotsused(self, value): 
 696          if isinstance(value,UINT): 
 697              self.__field_urlslotsused=value 
 698          else: 
 699              self.__field_urlslotsused=UINT(value,**{'sizeinbytes': 2}) 
 700   
 701 -    def __delfield_urlslotsused(self): del self.__field_urlslotsused 
 702   
 703      urlslotsused=property(__getfield_urlslotsused, __setfield_urlslotsused, __delfield_urlslotsused, None) 
 704   
 705 -    def __getfield_urlusedflags(self): 
 706          try: self.__field_urlusedflags 
 707          except: 
 708              self.__field_urlusedflags=LIST(**{'elementclass': _gen_p_sanyo7050_103, 'length': MAXURLS, 'createdefault': True}) 
 709          return self.__field_urlusedflags.getvalue() 
 710   
 711 -    def __setfield_urlusedflags(self, value): 
 712          if isinstance(value,LIST): 
 713              self.__field_urlusedflags=value 
 714          else: 
 715              self.__field_urlusedflags=LIST(value,**{'elementclass': _gen_p_sanyo7050_103, 'length': MAXURLS, 'createdefault': True}) 
 716   
 717 -    def __delfield_urlusedflags(self): del self.__field_urlusedflags 
 718   
 719      urlusedflags=property(__getfield_urlusedflags, __setfield_urlusedflags, __delfield_urlusedflags, None) 
 720   
 721 -    def __getfield_num_address(self): 
 722          return self.__field_num_address.getvalue() 
 723   
 724 -    def __setfield_num_address(self, value): 
 725          if isinstance(value,UINT): 
 726              self.__field_num_address=value 
 727          else: 
 728              self.__field_num_address=UINT(value,**{'sizeinbytes': 2}) 
 729   
 730 -    def __delfield_num_address(self): del self.__field_num_address 
 731   
 732      num_address=property(__getfield_num_address, __setfield_num_address, __delfield_num_address, None) 
 733   
 734 -    def __getfield_addressusedflags(self): 
 735          try: self.__field_addressusedflags 
 736          except: 
 737              self.__field_addressusedflags=LIST(**{'elementclass': _gen_p_sanyo7050_107, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 
 738          return self.__field_addressusedflags.getvalue() 
 739   
 740 -    def __setfield_addressusedflags(self, value): 
 741          if isinstance(value,LIST): 
 742              self.__field_addressusedflags=value 
 743          else: 
 744              self.__field_addressusedflags=LIST(value,**{'elementclass': _gen_p_sanyo7050_107, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 
 745   
 746 -    def __delfield_addressusedflags(self): del self.__field_addressusedflags 
 747   
 748      addressusedflags=property(__getfield_addressusedflags, __setfield_addressusedflags, __delfield_addressusedflags, None) 
 749   
 750 -    def __getfield_num_memo(self): 
 751          return self.__field_num_memo.getvalue() 
 752   
 753 -    def __setfield_num_memo(self, value): 
 754          if isinstance(value,UINT): 
 755              self.__field_num_memo=value 
 756          else: 
 757              self.__field_num_memo=UINT(value,**{'sizeinbytes': 2}) 
 758   
 759 -    def __delfield_num_memo(self): del self.__field_num_memo 
 760   
 761      num_memo=property(__getfield_num_memo, __setfield_num_memo, __delfield_num_memo, None) 
 762   
 763 -    def __getfield_memousedflags(self): 
 764          try: self.__field_memousedflags 
 765          except: 
 766              self.__field_memousedflags=LIST(**{'elementclass': _gen_p_sanyo7050_111, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 
 767          return self.__field_memousedflags.getvalue() 
 768   
 769 -    def __setfield_memousedflags(self, value): 
 770          if isinstance(value,LIST): 
 771              self.__field_memousedflags=value 
 772          else: 
 773              self.__field_memousedflags=LIST(value,**{'elementclass': _gen_p_sanyo7050_111, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 
 774   
 775 -    def __delfield_memousedflags(self): del self.__field_memousedflags 
 776   
 777      memousedflags=property(__getfield_memousedflags, __setfield_memousedflags, __delfield_memousedflags, None) 
 778   
 779 -    def __getfield_junk(self): 
 780          try: self.__field_junk 
 781          except: 
 782              self.__field_junk=UNKNOWN(**{'sizeinbytes': 391}) 
 783          return self.__field_junk.getvalue() 
 784   
 785 -    def __setfield_junk(self, value): 
 786          if isinstance(value,UNKNOWN): 
 787              self.__field_junk=value 
 788          else: 
 789              self.__field_junk=UNKNOWN(value,**{'sizeinbytes': 391}) 
 790   
 791 -    def __delfield_junk(self): del self.__field_junk 
 792   
 793      junk=property(__getfield_junk, __setfield_junk, __delfield_junk, None) 
 794   
 795 -    def iscontainer(self): 
 796          return True 
 797   
 798 -    def containerelements(self): 
 799          yield ('startcommand', self.__field_startcommand, "Starting command for R/W buf parts") 
 800          yield ('bufsize', self.__field_bufsize, None) 
 801          yield ('comment', self.__field_comment, None) 
 802          yield ('groupslotsused', self.__field_groupslotsused, None) 
 803          yield ('pad', self.__field_pad, None) 
 804          yield ('groupslotusedflags', self.__field_groupslotusedflags, None) 
 805          yield ('slotsused', self.__field_slotsused, None) 
 806          yield ('usedflags', self.__field_usedflags, None) 
 807          yield ('speeddialindex', self.__field_speeddialindex, None) 
 808          yield ('nameslotsused', self.__field_nameslotsused, "Always seems to be the same.  Why duplicated?") 
 809          yield ('nameusedflags', self.__field_nameusedflags, None) 
 810          yield ('sortorder', self.__field_sortorder, None) 
 811          yield ('pbfirstletters', self.__field_pbfirstletters, None) 
 812          yield ('numslotsused', self.__field_numslotsused, "Number of phone number slots used") 
 813          yield ('numusedflags', self.__field_numusedflags, None) 
 814          yield ('emailslotsused', self.__field_emailslotsused, None) 
 815          yield ('emailusedflags', self.__field_emailusedflags, None) 
 816          yield ('urlslotsused', self.__field_urlslotsused, None) 
 817          yield ('urlusedflags', self.__field_urlusedflags, None) 
 818          yield ('num_address', self.__field_num_address, None) 
 819          yield ('addressusedflags', self.__field_addressusedflags, None) 
 820          yield ('num_memo', self.__field_num_memo, None) 
 821          yield ('memousedflags', self.__field_memousedflags, None) 
 822          yield ('junk', self.__field_junk, None) 
 823   
 824   
 825   
 826   
 827 -class _gen_p_sanyo7050_79(BaseProtogenClass): 
 828      'Anonymous inner class' 
 829      __fields=['used'] 
 830   
 831 -    def __init__(self, *args, **kwargs): 
 832          dict={} 
 833          # What was supplied to this function 
 834          dict.update(kwargs) 
 835          # Parent constructor 
 836          super(_gen_p_sanyo7050_79,self).__init__(**dict) 
 837          if self.__class__ is _gen_p_sanyo7050_79: 
 838              self._update(args,dict) 
 839   
 840   
 841 -    def getfields(self): 
 842          return self.__fields 
 843   
 844   
 845 -    def _update(self, args, kwargs): 
 846          super(_gen_p_sanyo7050_79,self)._update(args,kwargs) 
 847          keys=kwargs.keys() 
 848          for key in keys: 
 849              if key in self.__fields: 
 850                  setattr(self, key, kwargs[key]) 
 851                  del kwargs[key] 
 852          # Were any unrecognized kwargs passed in? 
 853          if __debug__: 
 854              self._complainaboutunusedargs(_gen_p_sanyo7050_79,kwargs) 
 855          if len(args): 
 856              dict2={'sizeinbytes': 1} 
 857              dict2.update(kwargs) 
 858              kwargs=dict2 
 859              self.__field_used=UINT(*args,**dict2) 
 860          # Make all P fields that haven't already been constructed 
 861   
 862   
 863 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 864          'Writes this packet to the supplied buffer' 
 865          self._bufferstartoffset=buf.getcurrentoffset() 
 866          self.__field_used.writetobuffer(buf) 
 867          self._bufferendoffset=buf.getcurrentoffset() 
 868          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 869   
 870   
 871 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 872          'Reads this packet from the supplied buffer' 
 873          self._bufferstartoffset=buf.getcurrentoffset() 
 874          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 875          self.__field_used=UINT(**{'sizeinbytes': 1}) 
 876          self.__field_used.readfrombuffer(buf) 
 877          self._bufferendoffset=buf.getcurrentoffset() 
 878   
 879   
 880 -    def __getfield_used(self): 
 881          return self.__field_used.getvalue() 
 882   
 883 -    def __setfield_used(self, value): 
 884          if isinstance(value,UINT): 
 885              self.__field_used=value 
 886          else: 
 887              self.__field_used=UINT(value,**{'sizeinbytes': 1}) 
 888   
 889 -    def __delfield_used(self): del self.__field_used 
 890   
 891      used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 
 892   
 893 -    def iscontainer(self): 
 894          return True 
 895   
 896 -    def containerelements(self): 
 897          yield ('used', self.__field_used, "1 if slot in use") 
 898   
 899   
 900   
 901   
 902 -class _gen_p_sanyo7050_83(BaseProtogenClass): 
 903      'Anonymous inner class' 
 904      __fields=['used'] 
 905   
 906 -    def __init__(self, *args, **kwargs): 
 907          dict={} 
 908          # What was supplied to this function 
 909          dict.update(kwargs) 
 910          # Parent constructor 
 911          super(_gen_p_sanyo7050_83,self).__init__(**dict) 
 912          if self.__class__ is _gen_p_sanyo7050_83: 
 913              self._update(args,dict) 
 914   
 915   
 916 -    def getfields(self): 
 917          return self.__fields 
 918   
 919   
 920 -    def _update(self, args, kwargs): 
 921          super(_gen_p_sanyo7050_83,self)._update(args,kwargs) 
 922          keys=kwargs.keys() 
 923          for key in keys: 
 924              if key in self.__fields: 
 925                  setattr(self, key, kwargs[key]) 
 926                  del kwargs[key] 
 927          # Were any unrecognized kwargs passed in? 
 928          if __debug__: 
 929              self._complainaboutunusedargs(_gen_p_sanyo7050_83,kwargs) 
 930          if len(args): 
 931              dict2={'sizeinbytes': 1} 
 932              dict2.update(kwargs) 
 933              kwargs=dict2 
 934              self.__field_used=UINT(*args,**dict2) 
 935          # Make all P fields that haven't already been constructed 
 936   
 937   
 938 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 939          'Writes this packet to the supplied buffer' 
 940          self._bufferstartoffset=buf.getcurrentoffset() 
 941          self.__field_used.writetobuffer(buf) 
 942          self._bufferendoffset=buf.getcurrentoffset() 
 943          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 944   
 945   
 946 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 947          'Reads this packet from the supplied buffer' 
 948          self._bufferstartoffset=buf.getcurrentoffset() 
 949          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 950          self.__field_used=UINT(**{'sizeinbytes': 1}) 
 951          self.__field_used.readfrombuffer(buf) 
 952          self._bufferendoffset=buf.getcurrentoffset() 
 953   
 954   
 955 -    def __getfield_used(self): 
 956          return self.__field_used.getvalue() 
 957   
 958 -    def __setfield_used(self, value): 
 959          if isinstance(value,UINT): 
 960              self.__field_used=value 
 961          else: 
 962              self.__field_used=UINT(value,**{'sizeinbytes': 1}) 
 963   
 964 -    def __delfield_used(self): del self.__field_used 
 965   
 966      used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 
 967   
 968 -    def iscontainer(self): 
 969          return True 
 970   
 971 -    def containerelements(self): 
 972          yield ('used', self.__field_used, "1 if slot in use") 
 973   
 974   
 975   
 976   
 977 -class _gen_p_sanyo7050_85(BaseProtogenClass): 
 978      'Anonymous inner class' 
 979      __fields=['numslot'] 
 980   
 981 -    def __init__(self, *args, **kwargs): 
 982          dict={} 
 983          # What was supplied to this function 
 984          dict.update(kwargs) 
 985          # Parent constructor 
 986          super(_gen_p_sanyo7050_85,self).__init__(**dict) 
 987          if self.__class__ is _gen_p_sanyo7050_85: 
 988              self._update(args,dict) 
 989   
 990   
 991 -    def getfields(self): 
 992          return self.__fields 
 993   
 994   
 995 -    def _update(self, args, kwargs): 
 996          super(_gen_p_sanyo7050_85,self)._update(args,kwargs) 
 997          keys=kwargs.keys() 
 998          for key in keys: 
 999              if key in self.__fields: 
1000                  setattr(self, key, kwargs[key]) 
1001                  del kwargs[key] 
1002          # Were any unrecognized kwargs passed in? 
1003          if __debug__: 
1004              self._complainaboutunusedargs(_gen_p_sanyo7050_85,kwargs) 
1005          if len(args): 
1006              dict2={'sizeinbytes': 2, 'default': 0xffff} 
1007              dict2.update(kwargs) 
1008              kwargs=dict2 
1009              self.__field_numslot=UINT(*args,**dict2) 
1010          # Make all P fields that haven't already been constructed 
1011   
1012   
1013 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1014          'Writes this packet to the supplied buffer' 
1015          self._bufferstartoffset=buf.getcurrentoffset() 
1016          self.__field_numslot.writetobuffer(buf) 
1017          self._bufferendoffset=buf.getcurrentoffset() 
1018          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1019   
1020   
1021 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1022          'Reads this packet from the supplied buffer' 
1023          self._bufferstartoffset=buf.getcurrentoffset() 
1024          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1025          self.__field_numslot=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
1026          self.__field_numslot.readfrombuffer(buf) 
1027          self._bufferendoffset=buf.getcurrentoffset() 
1028   
1029   
1030 -    def __getfield_numslot(self): 
1031          return self.__field_numslot.getvalue() 
1032   
1033 -    def __setfield_numslot(self, value): 
1034          if isinstance(value,UINT): 
1035              self.__field_numslot=value 
1036          else: 
1037              self.__field_numslot=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff}) 
1038   
1039 -    def __delfield_numslot(self): del self.__field_numslot 
1040   
1041      numslot=property(__getfield_numslot, __setfield_numslot, __delfield_numslot, None) 
1042   
1043 -    def iscontainer(self): 
1044          return True 
1045   
1046 -    def containerelements(self): 
1047          yield ('numslot', self.__field_numslot, None) 
1048   
1049   
1050   
1051   
1052 -class _gen_p_sanyo7050_89(BaseProtogenClass): 
1053      'Anonymous inner class' 
1054      __fields=['used'] 
1055   
1056 -    def __init__(self, *args, **kwargs): 
1057          dict={} 
1058          # What was supplied to this function 
1059          dict.update(kwargs) 
1060          # Parent constructor 
1061          super(_gen_p_sanyo7050_89,self).__init__(**dict) 
1062          if self.__class__ is _gen_p_sanyo7050_89: 
1063              self._update(args,dict) 
1064   
1065   
1066 -    def getfields(self): 
1067          return self.__fields 
1068   
1069   
1070 -    def _update(self, args, kwargs): 
1071          super(_gen_p_sanyo7050_89,self)._update(args,kwargs) 
1072          keys=kwargs.keys() 
1073          for key in keys: 
1074              if key in self.__fields: 
1075                  setattr(self, key, kwargs[key]) 
1076                  del kwargs[key] 
1077          # Were any unrecognized kwargs passed in? 
1078          if __debug__: 
1079              self._complainaboutunusedargs(_gen_p_sanyo7050_89,kwargs) 
1080          if len(args): 
1081              dict2={'sizeinbytes': 1} 
1082              dict2.update(kwargs) 
1083              kwargs=dict2 
1084              self.__field_used=UINT(*args,**dict2) 
1085          # Make all P fields that haven't already been constructed 
1086   
1087   
1088 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1089          'Writes this packet to the supplied buffer' 
1090          self._bufferstartoffset=buf.getcurrentoffset() 
1091          self.__field_used.writetobuffer(buf) 
1092          self._bufferendoffset=buf.getcurrentoffset() 
1093          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1094   
1095   
1096 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1097          'Reads this packet from the supplied buffer' 
1098          self._bufferstartoffset=buf.getcurrentoffset() 
1099          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1100          self.__field_used=UINT(**{'sizeinbytes': 1}) 
1101          self.__field_used.readfrombuffer(buf) 
1102          self._bufferendoffset=buf.getcurrentoffset() 
1103   
1104   
1105 -    def __getfield_used(self): 
1106          return self.__field_used.getvalue() 
1107   
1108 -    def __setfield_used(self, value): 
1109          if isinstance(value,UINT): 
1110              self.__field_used=value 
1111          else: 
1112              self.__field_used=UINT(value,**{'sizeinbytes': 1}) 
1113   
1114 -    def __delfield_used(self): del self.__field_used 
1115   
1116      used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 
1117   
1118 -    def iscontainer(self): 
1119          return True 
1120   
1121 -    def containerelements(self): 
1122          yield ('used', self.__field_used, "1 if slot in use") 
1123   
1124   
1125   
1126   
1127 -class _gen_p_sanyo7050_91(BaseProtogenClass): 
1128      'Anonymous inner class' 
1129      __fields=['pbslot'] 
1130   
1131 -    def __init__(self, *args, **kwargs): 
1132          dict={} 
1133          # What was supplied to this function 
1134          dict.update(kwargs) 
1135          # Parent constructor 
1136          super(_gen_p_sanyo7050_91,self).__init__(**dict) 
1137          if self.__class__ is _gen_p_sanyo7050_91: 
1138              self._update(args,dict) 
1139   
1140   
1141 -    def getfields(self): 
1142          return self.__fields 
1143   
1144   
1145 -    def _update(self, args, kwargs): 
1146          super(_gen_p_sanyo7050_91,self)._update(args,kwargs) 
1147          keys=kwargs.keys() 
1148          for key in keys: 
1149              if key in self.__fields: 
1150                  setattr(self, key, kwargs[key]) 
1151                  del kwargs[key] 
1152          # Were any unrecognized kwargs passed in? 
1153          if __debug__: 
1154              self._complainaboutunusedargs(_gen_p_sanyo7050_91,kwargs) 
1155          if len(args): 
1156              dict2={'sizeinbytes': 2, 'default': 0xffff} 
1157              dict2.update(kwargs) 
1158              kwargs=dict2 
1159              self.__field_pbslot=UINT(*args,**dict2) 
1160          # Make all P fields that haven't already been constructed 
1161   
1162   
1163 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1164          'Writes this packet to the supplied buffer' 
1165          self._bufferstartoffset=buf.getcurrentoffset() 
1166          self.__field_pbslot.writetobuffer(buf) 
1167          self._bufferendoffset=buf.getcurrentoffset() 
1168          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1169   
1170   
1171 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1172          'Reads this packet from the supplied buffer' 
1173          self._bufferstartoffset=buf.getcurrentoffset() 
1174          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1175          self.__field_pbslot=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
1176          self.__field_pbslot.readfrombuffer(buf) 
1177          self._bufferendoffset=buf.getcurrentoffset() 
1178   
1179   
1180 -    def __getfield_pbslot(self): 
1181          return self.__field_pbslot.getvalue() 
1182   
1183 -    def __setfield_pbslot(self, value): 
1184          if isinstance(value,UINT): 
1185              self.__field_pbslot=value 
1186          else: 
1187              self.__field_pbslot=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff}) 
1188   
1189 -    def __delfield_pbslot(self): del self.__field_pbslot 
1190   
1191      pbslot=property(__getfield_pbslot, __setfield_pbslot, __delfield_pbslot, None) 
1192   
1193 -    def iscontainer(self): 
1194          return True 
1195   
1196 -    def containerelements(self): 
1197          yield ('pbslot', self.__field_pbslot, None) 
1198   
1199   
1200   
1201   
1202 -class _gen_p_sanyo7050_96(BaseProtogenClass): 
1203      'Anonymous inner class' 
1204      __fields=['used'] 
1205   
1206 -    def __init__(self, *args, **kwargs): 
1207          dict={} 
1208          # What was supplied to this function 
1209          dict.update(kwargs) 
1210          # Parent constructor 
1211          super(_gen_p_sanyo7050_96,self).__init__(**dict) 
1212          if self.__class__ is _gen_p_sanyo7050_96: 
1213              self._update(args,dict) 
1214   
1215   
1216 -    def getfields(self): 
1217          return self.__fields 
1218   
1219   
1220 -    def _update(self, args, kwargs): 
1221          super(_gen_p_sanyo7050_96,self)._update(args,kwargs) 
1222          keys=kwargs.keys() 
1223          for key in keys: 
1224              if key in self.__fields: 
1225                  setattr(self, key, kwargs[key]) 
1226                  del kwargs[key] 
1227          # Were any unrecognized kwargs passed in? 
1228          if __debug__: 
1229              self._complainaboutunusedargs(_gen_p_sanyo7050_96,kwargs) 
1230          if len(args): 
1231              dict2={'sizeinbytes': 1} 
1232              dict2.update(kwargs) 
1233              kwargs=dict2 
1234              self.__field_used=UINT(*args,**dict2) 
1235          # Make all P fields that haven't already been constructed 
1236   
1237   
1238 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1239          'Writes this packet to the supplied buffer' 
1240          self._bufferstartoffset=buf.getcurrentoffset() 
1241          self.__field_used.writetobuffer(buf) 
1242          self._bufferendoffset=buf.getcurrentoffset() 
1243          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1244   
1245   
1246 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1247          'Reads this packet from the supplied buffer' 
1248          self._bufferstartoffset=buf.getcurrentoffset() 
1249          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1250          self.__field_used=UINT(**{'sizeinbytes': 1}) 
1251          self.__field_used.readfrombuffer(buf) 
1252          self._bufferendoffset=buf.getcurrentoffset() 
1253   
1254   
1255 -    def __getfield_used(self): 
1256          return self.__field_used.getvalue() 
1257   
1258 -    def __setfield_used(self, value): 
1259          if isinstance(value,UINT): 
1260              self.__field_used=value 
1261          else: 
1262              self.__field_used=UINT(value,**{'sizeinbytes': 1}) 
1263   
1264 -    def __delfield_used(self): del self.__field_used 
1265   
1266      used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 
1267   
1268 -    def iscontainer(self): 
1269          return True 
1270   
1271 -    def containerelements(self): 
1272          yield ('used', self.__field_used, "1 if slot in use") 
1273   
1274   
1275   
1276   
1277 -class _gen_p_sanyo7050_100(BaseProtogenClass): 
1278      'Anonymous inner class' 
1279      __fields=['used'] 
1280   
1281 -    def __init__(self, *args, **kwargs): 
1282          dict={} 
1283          # What was supplied to this function 
1284          dict.update(kwargs) 
1285          # Parent constructor 
1286          super(_gen_p_sanyo7050_100,self).__init__(**dict) 
1287          if self.__class__ is _gen_p_sanyo7050_100: 
1288              self._update(args,dict) 
1289   
1290   
1291 -    def getfields(self): 
1292          return self.__fields 
1293   
1294   
1295 -    def _update(self, args, kwargs): 
1296          super(_gen_p_sanyo7050_100,self)._update(args,kwargs) 
1297          keys=kwargs.keys() 
1298          for key in keys: 
1299              if key in self.__fields: 
1300                  setattr(self, key, kwargs[key]) 
1301                  del kwargs[key] 
1302          # Were any unrecognized kwargs passed in? 
1303          if __debug__: 
1304              self._complainaboutunusedargs(_gen_p_sanyo7050_100,kwargs) 
1305          if len(args): 
1306              dict2={'sizeinbytes': 1} 
1307              dict2.update(kwargs) 
1308              kwargs=dict2 
1309              self.__field_used=UINT(*args,**dict2) 
1310          # Make all P fields that haven't already been constructed 
1311   
1312   
1313 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1314          'Writes this packet to the supplied buffer' 
1315          self._bufferstartoffset=buf.getcurrentoffset() 
1316          self.__field_used.writetobuffer(buf) 
1317          self._bufferendoffset=buf.getcurrentoffset() 
1318          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1319   
1320   
1321 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1322          'Reads this packet from the supplied buffer' 
1323          self._bufferstartoffset=buf.getcurrentoffset() 
1324          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1325          self.__field_used=UINT(**{'sizeinbytes': 1}) 
1326          self.__field_used.readfrombuffer(buf) 
1327          self._bufferendoffset=buf.getcurrentoffset() 
1328   
1329   
1330 -    def __getfield_used(self): 
1331          return self.__field_used.getvalue() 
1332   
1333 -    def __setfield_used(self, value): 
1334          if isinstance(value,UINT): 
1335              self.__field_used=value 
1336          else: 
1337              self.__field_used=UINT(value,**{'sizeinbytes': 1}) 
1338   
1339 -    def __delfield_used(self): del self.__field_used 
1340   
1341      used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 
1342   
1343 -    def iscontainer(self): 
1344          return True 
1345   
1346 -    def containerelements(self): 
1347          yield ('used', self.__field_used, "1 if slot in use") 
1348   
1349   
1350   
1351   
1352 -class _gen_p_sanyo7050_103(BaseProtogenClass): 
1353      'Anonymous inner class' 
1354      __fields=['used'] 
1355   
1356 -    def __init__(self, *args, **kwargs): 
1357          dict={} 
1358          # What was supplied to this function 
1359          dict.update(kwargs) 
1360          # Parent constructor 
1361          super(_gen_p_sanyo7050_103,self).__init__(**dict) 
1362          if self.__class__ is _gen_p_sanyo7050_103: 
1363              self._update(args,dict) 
1364   
1365   
1366 -    def getfields(self): 
1367          return self.__fields 
1368   
1369   
1370 -    def _update(self, args, kwargs): 
1371          super(_gen_p_sanyo7050_103,self)._update(args,kwargs) 
1372          keys=kwargs.keys() 
1373          for key in keys: 
1374              if key in self.__fields: 
1375                  setattr(self, key, kwargs[key]) 
1376                  del kwargs[key] 
1377          # Were any unrecognized kwargs passed in? 
1378          if __debug__: 
1379              self._complainaboutunusedargs(_gen_p_sanyo7050_103,kwargs) 
1380          if len(args): 
1381              dict2={'sizeinbytes': 1} 
1382              dict2.update(kwargs) 
1383              kwargs=dict2 
1384              self.__field_used=UINT(*args,**dict2) 
1385          # Make all P fields that haven't already been constructed 
1386   
1387   
1388 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1389          'Writes this packet to the supplied buffer' 
1390          self._bufferstartoffset=buf.getcurrentoffset() 
1391          self.__field_used.writetobuffer(buf) 
1392          self._bufferendoffset=buf.getcurrentoffset() 
1393          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1394   
1395   
1396 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1397          'Reads this packet from the supplied buffer' 
1398          self._bufferstartoffset=buf.getcurrentoffset() 
1399          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1400          self.__field_used=UINT(**{'sizeinbytes': 1}) 
1401          self.__field_used.readfrombuffer(buf) 
1402          self._bufferendoffset=buf.getcurrentoffset() 
1403   
1404   
1405 -    def __getfield_used(self): 
1406          return self.__field_used.getvalue() 
1407   
1408 -    def __setfield_used(self, value): 
1409          if isinstance(value,UINT): 
1410              self.__field_used=value 
1411          else: 
1412              self.__field_used=UINT(value,**{'sizeinbytes': 1}) 
1413   
1414 -    def __delfield_used(self): del self.__field_used 
1415   
1416      used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 
1417   
1418 -    def iscontainer(self): 
1419          return True 
1420   
1421 -    def containerelements(self): 
1422          yield ('used', self.__field_used, "1 if slot in use") 
1423   
1424   
1425   
1426   
1427 -class _gen_p_sanyo7050_107(BaseProtogenClass): 
1428      'Anonymous inner class' 
1429      __fields=['used'] 
1430   
1431 -    def __init__(self, *args, **kwargs): 
1432          dict={} 
1433          # What was supplied to this function 
1434          dict.update(kwargs) 
1435          # Parent constructor 
1436          super(_gen_p_sanyo7050_107,self).__init__(**dict) 
1437          if self.__class__ is _gen_p_sanyo7050_107: 
1438              self._update(args,dict) 
1439   
1440   
1441 -    def getfields(self): 
1442          return self.__fields 
1443   
1444   
1445 -    def _update(self, args, kwargs): 
1446          super(_gen_p_sanyo7050_107,self)._update(args,kwargs) 
1447          keys=kwargs.keys() 
1448          for key in keys: 
1449              if key in self.__fields: 
1450                  setattr(self, key, kwargs[key]) 
1451                  del kwargs[key] 
1452          # Were any unrecognized kwargs passed in? 
1453          if __debug__: 
1454              self._complainaboutunusedargs(_gen_p_sanyo7050_107,kwargs) 
1455          if len(args): 
1456              dict2={'sizeinbytes': 1} 
1457              dict2.update(kwargs) 
1458              kwargs=dict2 
1459              self.__field_used=UINT(*args,**dict2) 
1460          # Make all P fields that haven't already been constructed 
1461   
1462   
1463 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1464          'Writes this packet to the supplied buffer' 
1465          self._bufferstartoffset=buf.getcurrentoffset() 
1466          self.__field_used.writetobuffer(buf) 
1467          self._bufferendoffset=buf.getcurrentoffset() 
1468          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1469   
1470   
1471 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1472          'Reads this packet from the supplied buffer' 
1473          self._bufferstartoffset=buf.getcurrentoffset() 
1474          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1475          self.__field_used=UINT(**{'sizeinbytes': 1}) 
1476          self.__field_used.readfrombuffer(buf) 
1477          self._bufferendoffset=buf.getcurrentoffset() 
1478   
1479   
1480 -    def __getfield_used(self): 
1481          return self.__field_used.getvalue() 
1482   
1483 -    def __setfield_used(self, value): 
1484          if isinstance(value,UINT): 
1485              self.__field_used=value 
1486          else: 
1487              self.__field_used=UINT(value,**{'sizeinbytes': 1}) 
1488   
1489 -    def __delfield_used(self): del self.__field_used 
1490   
1491      used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 
1492   
1493 -    def iscontainer(self): 
1494          return True 
1495   
1496 -    def containerelements(self): 
1497          yield ('used', self.__field_used, "1 if slot in use") 
1498   
1499   
1500   
1501   
1502 -class _gen_p_sanyo7050_111(BaseProtogenClass): 
1503      'Anonymous inner class' 
1504      __fields=['used'] 
1505   
1506 -    def __init__(self, *args, **kwargs): 
1507          dict={} 
1508          # What was supplied to this function 
1509          dict.update(kwargs) 
1510          # Parent constructor 
1511          super(_gen_p_sanyo7050_111,self).__init__(**dict) 
1512          if self.__class__ is _gen_p_sanyo7050_111: 
1513              self._update(args,dict) 
1514   
1515   
1516 -    def getfields(self): 
1517          return self.__fields 
1518   
1519   
1520 -    def _update(self, args, kwargs): 
1521          super(_gen_p_sanyo7050_111,self)._update(args,kwargs) 
1522          keys=kwargs.keys() 
1523          for key in keys: 
1524              if key in self.__fields: 
1525                  setattr(self, key, kwargs[key]) 
1526                  del kwargs[key] 
1527          # Were any unrecognized kwargs passed in? 
1528          if __debug__: 
1529              self._complainaboutunusedargs(_gen_p_sanyo7050_111,kwargs) 
1530          if len(args): 
1531              dict2={'sizeinbytes': 1} 
1532              dict2.update(kwargs) 
1533              kwargs=dict2 
1534              self.__field_used=UINT(*args,**dict2) 
1535          # Make all P fields that haven't already been constructed 
1536   
1537   
1538 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1539          'Writes this packet to the supplied buffer' 
1540          self._bufferstartoffset=buf.getcurrentoffset() 
1541          self.__field_used.writetobuffer(buf) 
1542          self._bufferendoffset=buf.getcurrentoffset() 
1543          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1544   
1545   
1546 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1547          'Reads this packet from the supplied buffer' 
1548          self._bufferstartoffset=buf.getcurrentoffset() 
1549          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1550          self.__field_used=UINT(**{'sizeinbytes': 1}) 
1551          self.__field_used.readfrombuffer(buf) 
1552          self._bufferendoffset=buf.getcurrentoffset() 
1553   
1554   
1555 -    def __getfield_used(self): 
1556          return self.__field_used.getvalue() 
1557   
1558 -    def __setfield_used(self, value): 
1559          if isinstance(value,UINT): 
1560              self.__field_used=value 
1561          else: 
1562              self.__field_used=UINT(value,**{'sizeinbytes': 1}) 
1563   
1564 -    def __delfield_used(self): del self.__field_used 
1565   
1566      used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 
1567   
1568 -    def iscontainer(self): 
1569          return True 
1570   
1571 -    def containerelements(self): 
1572          yield ('used', self.__field_used, "1 if slot in use") 
1573   
1574   
1575   
1576   
1577 -class contactindexrequest(BaseProtogenClass): 
1578      __fields=['header', 'slot'] 
1579   
1580 -    def __init__(self, *args, **kwargs): 
1581          dict={} 
1582          # What was supplied to this function 
1583          dict.update(kwargs) 
1584          # Parent constructor 
1585          super(contactindexrequest,self).__init__(**dict) 
1586          if self.__class__ is contactindexrequest: 
1587              self._update(args,dict) 
1588   
1589   
1590 -    def getfields(self): 
1591          return self.__fields 
1592   
1593   
1594 -    def _update(self, args, kwargs): 
1595          super(contactindexrequest,self)._update(args,kwargs) 
1596          keys=kwargs.keys() 
1597          for key in keys: 
1598              if key in self.__fields: 
1599                  setattr(self, key, kwargs[key]) 
1600                  del kwargs[key] 
1601          # Were any unrecognized kwargs passed in? 
1602          if __debug__: 
1603              self._complainaboutunusedargs(contactindexrequest,kwargs) 
1604          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1605          # Make all P fields that haven't already been constructed 
1606   
1607   
1608 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1609          'Writes this packet to the supplied buffer' 
1610          self._bufferstartoffset=buf.getcurrentoffset() 
1611          try: self.__field_header 
1612          except: 
1613              self.__field_header=sanyoheader(**{'packettype': 0xca,                   'command': 0x38}) 
1614          self.__field_header.writetobuffer(buf) 
1615          self.__field_slot.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_header=sanyoheader(**{'packettype': 0xca,                   'command': 0x38}) 
1625          self.__field_header.readfrombuffer(buf) 
1626          self.__field_slot=UINT(**{'sizeinbytes': 2}) 
1627          self.__field_slot.readfrombuffer(buf) 
1628          self._bufferendoffset=buf.getcurrentoffset() 
1629   
1630   
1631 -    def __getfield_header(self): 
1632          try: self.__field_header 
1633          except: 
1634              self.__field_header=sanyoheader(**{'packettype': 0xca,                   'command': 0x38}) 
1635          return self.__field_header.getvalue() 
1636   
1637 -    def __setfield_header(self, value): 
1638          if isinstance(value,sanyoheader): 
1639              self.__field_header=value 
1640          else: 
1641              self.__field_header=sanyoheader(value,**{'packettype': 0xca,                   'command': 0x38}) 
1642   
1643 -    def __delfield_header(self): del self.__field_header 
1644   
1645      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
1646   
1647 -    def __getfield_slot(self): 
1648          return self.__field_slot.getvalue() 
1649   
1650 -    def __setfield_slot(self, value): 
1651          if isinstance(value,UINT): 
1652              self.__field_slot=value 
1653          else: 
1654              self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 
1655   
1656 -    def __delfield_slot(self): del self.__field_slot 
1657   
1658      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
1659   
1660 -    def iscontainer(self): 
1661          return True 
1662   
1663 -    def containerelements(self): 
1664          yield ('header', self.__field_header, None) 
1665          yield ('slot', self.__field_slot, None) 
1666   
1667   
1668   
1669   
1670 -class contactindexupdaterequest(BaseProtogenClass): 
1671      __fields=['header', 'slot', 'entry'] 
1672   
1673 -    def __init__(self, *args, **kwargs): 
1674          dict={} 
1675          # What was supplied to this function 
1676          dict.update(kwargs) 
1677          # Parent constructor 
1678          super(contactindexupdaterequest,self).__init__(**dict) 
1679          if self.__class__ is contactindexupdaterequest: 
1680              self._update(args,dict) 
1681   
1682   
1683 -    def getfields(self): 
1684          return self.__fields 
1685   
1686   
1687 -    def _update(self, args, kwargs): 
1688          super(contactindexupdaterequest,self)._update(args,kwargs) 
1689          keys=kwargs.keys() 
1690          for key in keys: 
1691              if key in self.__fields: 
1692                  setattr(self, key, kwargs[key]) 
1693                  del kwargs[key] 
1694          # Were any unrecognized kwargs passed in? 
1695          if __debug__: 
1696              self._complainaboutunusedargs(contactindexupdaterequest,kwargs) 
1697          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1698          # Make all P fields that haven't already been constructed 
1699   
1700   
1701 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1702          'Writes this packet to the supplied buffer' 
1703          self._bufferstartoffset=buf.getcurrentoffset() 
1704          try: self.__field_header 
1705          except: 
1706              self.__field_header=sanyowriteheader(**{'packettype': 0xca,                   'command': 0x38}) 
1707          self.__field_header.writetobuffer(buf) 
1708          self.__field_slot.writetobuffer(buf) 
1709          try: self.__field_entry 
1710          except: 
1711              self.__field_entry=contactindexentry() 
1712          self.__field_entry.writetobuffer(buf) 
1713          self._bufferendoffset=buf.getcurrentoffset() 
1714          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1715   
1716   
1717 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1718          'Reads this packet from the supplied buffer' 
1719          self._bufferstartoffset=buf.getcurrentoffset() 
1720          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1721          self.__field_header=sanyowriteheader(**{'packettype': 0xca,                   'command': 0x38}) 
1722          self.__field_header.readfrombuffer(buf) 
1723          self.__field_slot=UINT(**{'sizeinbytes': 2}) 
1724          self.__field_slot.readfrombuffer(buf) 
1725          self.__field_entry=contactindexentry() 
1726          self.__field_entry.readfrombuffer(buf) 
1727          self._bufferendoffset=buf.getcurrentoffset() 
1728   
1729   
1730 -    def __getfield_header(self): 
1731          try: self.__field_header 
1732          except: 
1733              self.__field_header=sanyowriteheader(**{'packettype': 0xca,                   'command': 0x38}) 
1734          return self.__field_header.getvalue() 
1735   
1736 -    def __setfield_header(self, value): 
1737          if isinstance(value,sanyowriteheader): 
1738              self.__field_header=value 
1739          else: 
1740              self.__field_header=sanyowriteheader(value,**{'packettype': 0xca,                   'command': 0x38}) 
1741   
1742 -    def __delfield_header(self): del self.__field_header 
1743   
1744      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
1745   
1746 -    def __getfield_slot(self): 
1747          return self.__field_slot.getvalue() 
1748   
1749 -    def __setfield_slot(self, value): 
1750          if isinstance(value,UINT): 
1751              self.__field_slot=value 
1752          else: 
1753              self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 
1754   
1755 -    def __delfield_slot(self): del self.__field_slot 
1756   
1757      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
1758   
1759 -    def __getfield_entry(self): 
1760          try: self.__field_entry 
1761          except: 
1762              self.__field_entry=contactindexentry() 
1763          return self.__field_entry.getvalue() 
1764   
1765 -    def __setfield_entry(self, value): 
1766          if isinstance(value,contactindexentry): 
1767              self.__field_entry=value 
1768          else: 
1769              self.__field_entry=contactindexentry(value,) 
1770   
1771 -    def __delfield_entry(self): del self.__field_entry 
1772   
1773      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
1774   
1775 -    def iscontainer(self): 
1776          return True 
1777   
1778 -    def containerelements(self): 
1779          yield ('header', self.__field_header, None) 
1780          yield ('slot', self.__field_slot, None) 
1781          yield ('entry', self.__field_entry, None) 
1782   
1783   
1784   
1785   
1786 -class numberrequest(BaseProtogenClass): 
1787      __fields=['header', 'slot'] 
1788   
1789 -    def __init__(self, *args, **kwargs): 
1790          dict={} 
1791          # What was supplied to this function 
1792          dict.update(kwargs) 
1793          # Parent constructor 
1794          super(numberrequest,self).__init__(**dict) 
1795          if self.__class__ is numberrequest: 
1796              self._update(args,dict) 
1797   
1798   
1799 -    def getfields(self): 
1800          return self.__fields 
1801   
1802   
1803 -    def _update(self, args, kwargs): 
1804          super(numberrequest,self)._update(args,kwargs) 
1805          keys=kwargs.keys() 
1806          for key in keys: 
1807              if key in self.__fields: 
1808                  setattr(self, key, kwargs[key]) 
1809                  del kwargs[key] 
1810          # Were any unrecognized kwargs passed in? 
1811          if __debug__: 
1812              self._complainaboutunusedargs(numberrequest,kwargs) 
1813          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1814          # Make all P fields that haven't already been constructed 
1815   
1816   
1817 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1818          'Writes this packet to the supplied buffer' 
1819          self._bufferstartoffset=buf.getcurrentoffset() 
1820          try: self.__field_header 
1821          except: 
1822              self.__field_header=sanyoheader(**{'packettype': 0xca,                   'command': 0x3f}) 
1823          self.__field_header.writetobuffer(buf) 
1824          self.__field_slot.writetobuffer(buf) 
1825          self._bufferendoffset=buf.getcurrentoffset() 
1826          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1827   
1828   
1829 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1830          'Reads this packet from the supplied buffer' 
1831          self._bufferstartoffset=buf.getcurrentoffset() 
1832          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1833          self.__field_header=sanyoheader(**{'packettype': 0xca,                   'command': 0x3f}) 
1834          self.__field_header.readfrombuffer(buf) 
1835          self.__field_slot=UINT(**{'sizeinbytes': 2}) 
1836          self.__field_slot.readfrombuffer(buf) 
1837          self._bufferendoffset=buf.getcurrentoffset() 
1838   
1839   
1840 -    def __getfield_header(self): 
1841          try: self.__field_header 
1842          except: 
1843              self.__field_header=sanyoheader(**{'packettype': 0xca,                   'command': 0x3f}) 
1844          return self.__field_header.getvalue() 
1845   
1846 -    def __setfield_header(self, value): 
1847          if isinstance(value,sanyoheader): 
1848              self.__field_header=value 
1849          else: 
1850              self.__field_header=sanyoheader(value,**{'packettype': 0xca,                   'command': 0x3f}) 
1851   
1852 -    def __delfield_header(self): del self.__field_header 
1853   
1854      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
1855   
1856 -    def __getfield_slot(self): 
1857          return self.__field_slot.getvalue() 
1858   
1859 -    def __setfield_slot(self, value): 
1860          if isinstance(value,UINT): 
1861              self.__field_slot=value 
1862          else: 
1863              self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 
1864   
1865 -    def __delfield_slot(self): del self.__field_slot 
1866   
1867      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
1868   
1869 -    def iscontainer(self): 
1870          return True 
1871   
1872 -    def containerelements(self): 
1873          yield ('header', self.__field_header, None) 
1874          yield ('slot', self.__field_slot, None) 
1875   
1876   
1877   
1878   
1879 -class numberupdaterequest(BaseProtogenClass): 
1880      __fields=['header', 'slot', 'entry'] 
1881   
1882 -    def __init__(self, *args, **kwargs): 
1883          dict={} 
1884          # What was supplied to this function 
1885          dict.update(kwargs) 
1886          # Parent constructor 
1887          super(numberupdaterequest,self).__init__(**dict) 
1888          if self.__class__ is numberupdaterequest: 
1889              self._update(args,dict) 
1890   
1891   
1892 -    def getfields(self): 
1893          return self.__fields 
1894   
1895   
1896 -    def _update(self, args, kwargs): 
1897          super(numberupdaterequest,self)._update(args,kwargs) 
1898          keys=kwargs.keys() 
1899          for key in keys: 
1900              if key in self.__fields: 
1901                  setattr(self, key, kwargs[key]) 
1902                  del kwargs[key] 
1903          # Were any unrecognized kwargs passed in? 
1904          if __debug__: 
1905              self._complainaboutunusedargs(numberupdaterequest,kwargs) 
1906          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1907          # Make all P fields that haven't already been constructed 
1908   
1909   
1910 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1911          'Writes this packet to the supplied buffer' 
1912          self._bufferstartoffset=buf.getcurrentoffset() 
1913          try: self.__field_header 
1914          except: 
1915              self.__field_header=sanyowriteheader(**{'packettype': 0xca,                   'command': 0x3f}) 
1916          self.__field_header.writetobuffer(buf) 
1917          self.__field_slot.writetobuffer(buf) 
1918          try: self.__field_entry 
1919          except: 
1920              self.__field_entry=numberentry() 
1921          self.__field_entry.writetobuffer(buf) 
1922          self._bufferendoffset=buf.getcurrentoffset() 
1923          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1924   
1925   
1926 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1927          'Reads this packet from the supplied buffer' 
1928          self._bufferstartoffset=buf.getcurrentoffset() 
1929          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1930          self.__field_header=sanyowriteheader(**{'packettype': 0xca,                   'command': 0x3f}) 
1931          self.__field_header.readfrombuffer(buf) 
1932          self.__field_slot=UINT(**{'sizeinbytes': 2}) 
1933          self.__field_slot.readfrombuffer(buf) 
1934          self.__field_entry=numberentry() 
1935          self.__field_entry.readfrombuffer(buf) 
1936          self._bufferendoffset=buf.getcurrentoffset() 
1937   
1938   
1939 -    def __getfield_header(self): 
1940          try: self.__field_header 
1941          except: 
1942              self.__field_header=sanyowriteheader(**{'packettype': 0xca,                   'command': 0x3f}) 
1943          return self.__field_header.getvalue() 
1944   
1945 -    def __setfield_header(self, value): 
1946          if isinstance(value,sanyowriteheader): 
1947              self.__field_header=value 
1948          else: 
1949              self.__field_header=sanyowriteheader(value,**{'packettype': 0xca,                   'command': 0x3f}) 
1950   
1951 -    def __delfield_header(self): del self.__field_header 
1952   
1953      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
1954   
1955 -    def __getfield_slot(self): 
1956          return self.__field_slot.getvalue() 
1957   
1958 -    def __setfield_slot(self, value): 
1959          if isinstance(value,UINT): 
1960              self.__field_slot=value 
1961          else: 
1962              self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 
1963   
1964 -    def __delfield_slot(self): del self.__field_slot 
1965   
1966      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
1967   
1968 -    def __getfield_entry(self): 
1969          try: self.__field_entry 
1970          except: 
1971              self.__field_entry=numberentry() 
1972          return self.__field_entry.getvalue() 
1973   
1974 -    def __setfield_entry(self, value): 
1975          if isinstance(value,numberentry): 
1976              self.__field_entry=value 
1977          else: 
1978              self.__field_entry=numberentry(value,) 
1979   
1980 -    def __delfield_entry(self): del self.__field_entry 
1981   
1982      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
1983   
1984 -    def iscontainer(self): 
1985          return True 
1986   
1987 -    def containerelements(self): 
1988          yield ('header', self.__field_header, None) 
1989          yield ('slot', self.__field_slot, None) 
1990          yield ('entry', self.__field_entry, None) 
1991   
1992   
1993   
1994   
1995 -class namerequest(BaseProtogenClass): 
1996      __fields=['header', 'slot'] 
1997   
1998 -    def __init__(self, *args, **kwargs): 
1999          dict={} 
2000          # What was supplied to this function 
2001          dict.update(kwargs) 
2002          # Parent constructor 
2003          super(namerequest,self).__init__(**dict) 
2004          if self.__class__ is namerequest: 
2005              self._update(args,dict) 
2006   
2007   
2008 -    def getfields(self): 
2009          return self.__fields 
2010   
2011   
2012 -    def _update(self, args, kwargs): 
2013          super(namerequest,self)._update(args,kwargs) 
2014          keys=kwargs.keys() 
2015          for key in keys: 
2016              if key in self.__fields: 
2017                  setattr(self, key, kwargs[key]) 
2018                  del kwargs[key] 
2019          # Were any unrecognized kwargs passed in? 
2020          if __debug__: 
2021              self._complainaboutunusedargs(namerequest,kwargs) 
2022          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2023          # Make all P fields that haven't already been constructed 
2024   
2025   
2026 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2027          'Writes this packet to the supplied buffer' 
2028          self._bufferstartoffset=buf.getcurrentoffset() 
2029          try: self.__field_header 
2030          except: 
2031              self.__field_header=sanyoheader(**{'packettype': 0xca,                   'command': 0x3c}) 
2032          self.__field_header.writetobuffer(buf) 
2033          self.__field_slot.writetobuffer(buf) 
2034          self._bufferendoffset=buf.getcurrentoffset() 
2035          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2036   
2037   
2038 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2039          'Reads this packet from the supplied buffer' 
2040          self._bufferstartoffset=buf.getcurrentoffset() 
2041          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2042          self.__field_header=sanyoheader(**{'packettype': 0xca,                   'command': 0x3c}) 
2043          self.__field_header.readfrombuffer(buf) 
2044          self.__field_slot=UINT(**{'sizeinbytes': 2}) 
2045          self.__field_slot.readfrombuffer(buf) 
2046          self._bufferendoffset=buf.getcurrentoffset() 
2047   
2048   
2049 -    def __getfield_header(self): 
2050          try: self.__field_header 
2051          except: 
2052              self.__field_header=sanyoheader(**{'packettype': 0xca,                   'command': 0x3c}) 
2053          return self.__field_header.getvalue() 
2054   
2055 -    def __setfield_header(self, value): 
2056          if isinstance(value,sanyoheader): 
2057              self.__field_header=value 
2058          else: 
2059              self.__field_header=sanyoheader(value,**{'packettype': 0xca,                   'command': 0x3c}) 
2060   
2061 -    def __delfield_header(self): del self.__field_header 
2062   
2063      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
2064   
2065 -    def __getfield_slot(self): 
2066          return self.__field_slot.getvalue() 
2067   
2068 -    def __setfield_slot(self, value): 
2069          if isinstance(value,UINT): 
2070              self.__field_slot=value 
2071          else: 
2072              self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 
2073   
2074 -    def __delfield_slot(self): del self.__field_slot 
2075   
2076      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
2077   
2078 -    def iscontainer(self): 
2079          return True 
2080   
2081 -    def containerelements(self): 
2082          yield ('header', self.__field_header, None) 
2083          yield ('slot', self.__field_slot, None) 
2084   
2085   
2086   
2087   
2088 -class nameupdaterequest(BaseProtogenClass): 
2089      __fields=['header', 'slot', 'entry'] 
2090   
2091 -    def __init__(self, *args, **kwargs): 
2092          dict={} 
2093          # What was supplied to this function 
2094          dict.update(kwargs) 
2095          # Parent constructor 
2096          super(nameupdaterequest,self).__init__(**dict) 
2097          if self.__class__ is nameupdaterequest: 
2098              self._update(args,dict) 
2099   
2100   
2101 -    def getfields(self): 
2102          return self.__fields 
2103   
2104   
2105 -    def _update(self, args, kwargs): 
2106          super(nameupdaterequest,self)._update(args,kwargs) 
2107          keys=kwargs.keys() 
2108          for key in keys: 
2109              if key in self.__fields: 
2110                  setattr(self, key, kwargs[key]) 
2111                  del kwargs[key] 
2112          # Were any unrecognized kwargs passed in? 
2113          if __debug__: 
2114              self._complainaboutunusedargs(nameupdaterequest,kwargs) 
2115          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2116          # Make all P fields that haven't already been constructed 
2117   
2118   
2119 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2120          'Writes this packet to the supplied buffer' 
2121          self._bufferstartoffset=buf.getcurrentoffset() 
2122          try: self.__field_header 
2123          except: 
2124              self.__field_header=sanyowriteheader(**{'packettype': 0xca,                   'command': 0x3c}) 
2125          self.__field_header.writetobuffer(buf) 
2126          self.__field_slot.writetobuffer(buf) 
2127          try: self.__field_entry 
2128          except: 
2129              self.__field_entry=nameentry() 
2130          self.__field_entry.writetobuffer(buf) 
2131          self._bufferendoffset=buf.getcurrentoffset() 
2132          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2133   
2134   
2135 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2136          'Reads this packet from the supplied buffer' 
2137          self._bufferstartoffset=buf.getcurrentoffset() 
2138          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2139          self.__field_header=sanyowriteheader(**{'packettype': 0xca,                   'command': 0x3c}) 
2140          self.__field_header.readfrombuffer(buf) 
2141          self.__field_slot=UINT(**{'sizeinbytes': 2}) 
2142          self.__field_slot.readfrombuffer(buf) 
2143          self.__field_entry=nameentry() 
2144          self.__field_entry.readfrombuffer(buf) 
2145          self._bufferendoffset=buf.getcurrentoffset() 
2146   
2147   
2148 -    def __getfield_header(self): 
2149          try: self.__field_header 
2150          except: 
2151              self.__field_header=sanyowriteheader(**{'packettype': 0xca,                   'command': 0x3c}) 
2152          return self.__field_header.getvalue() 
2153   
2154 -    def __setfield_header(self, value): 
2155          if isinstance(value,sanyowriteheader): 
2156              self.__field_header=value 
2157          else: 
2158              self.__field_header=sanyowriteheader(value,**{'packettype': 0xca,                   'command': 0x3c}) 
2159   
2160 -    def __delfield_header(self): del self.__field_header 
2161   
2162      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
2163   
2164 -    def __getfield_slot(self): 
2165          return self.__field_slot.getvalue() 
2166   
2167 -    def __setfield_slot(self, value): 
2168          if isinstance(value,UINT): 
2169              self.__field_slot=value 
2170          else: 
2171              self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 
2172   
2173 -    def __delfield_slot(self): del self.__field_slot 
2174   
2175      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
2176   
2177 -    def __getfield_entry(self): 
2178          try: self.__field_entry 
2179          except: 
2180              self.__field_entry=nameentry() 
2181          return self.__field_entry.getvalue() 
2182   
2183 -    def __setfield_entry(self, value): 
2184          if isinstance(value,nameentry): 
2185              self.__field_entry=value 
2186          else: 
2187              self.__field_entry=nameentry(value,) 
2188   
2189 -    def __delfield_entry(self): del self.__field_entry 
2190   
2191      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
2192   
2193 -    def iscontainer(self): 
2194          return True 
2195   
2196 -    def containerelements(self): 
2197          yield ('header', self.__field_header, None) 
2198          yield ('slot', self.__field_slot, None) 
2199          yield ('entry', self.__field_entry, None) 
2200   
2201   
2202   
2203   
2204 -class emailrequest(BaseProtogenClass): 
2205      __fields=['header', 'slot'] 
2206   
2207 -    def __init__(self, *args, **kwargs): 
2208          dict={} 
2209          # What was supplied to this function 
2210          dict.update(kwargs) 
2211          # Parent constructor 
2212          super(emailrequest,self).__init__(**dict) 
2213          if self.__class__ is emailrequest: 
2214              self._update(args,dict) 
2215   
2216   
2217 -    def getfields(self): 
2218          return self.__fields 
2219   
2220   
2221 -    def _update(self, args, kwargs): 
2222          super(emailrequest,self)._update(args,kwargs) 
2223          keys=kwargs.keys() 
2224          for key in keys: 
2225              if key in self.__fields: 
2226                  setattr(self, key, kwargs[key]) 
2227                  del kwargs[key] 
2228          # Were any unrecognized kwargs passed in? 
2229          if __debug__: 
2230              self._complainaboutunusedargs(emailrequest,kwargs) 
2231          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2232          # Make all P fields that haven't already been constructed 
2233   
2234   
2235 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2236          'Writes this packet to the supplied buffer' 
2237          self._bufferstartoffset=buf.getcurrentoffset() 
2238          try: self.__field_header 
2239          except: 
2240              self.__field_header=sanyoheader(**{'packettype': 0xca,                   'command': 0x43}) 
2241          self.__field_header.writetobuffer(buf) 
2242          self.__field_slot.writetobuffer(buf) 
2243          self._bufferendoffset=buf.getcurrentoffset() 
2244          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2245   
2246   
2247 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2248          'Reads this packet from the supplied buffer' 
2249          self._bufferstartoffset=buf.getcurrentoffset() 
2250          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2251          self.__field_header=sanyoheader(**{'packettype': 0xca,                   'command': 0x43}) 
2252          self.__field_header.readfrombuffer(buf) 
2253          self.__field_slot=UINT(**{'sizeinbytes': 2}) 
2254          self.__field_slot.readfrombuffer(buf) 
2255          self._bufferendoffset=buf.getcurrentoffset() 
2256   
2257   
2258 -    def __getfield_header(self): 
2259          try: self.__field_header 
2260          except: 
2261              self.__field_header=sanyoheader(**{'packettype': 0xca,                   'command': 0x43}) 
2262          return self.__field_header.getvalue() 
2263   
2264 -    def __setfield_header(self, value): 
2265          if isinstance(value,sanyoheader): 
2266              self.__field_header=value 
2267          else: 
2268              self.__field_header=sanyoheader(value,**{'packettype': 0xca,                   'command': 0x43}) 
2269   
2270 -    def __delfield_header(self): del self.__field_header 
2271   
2272      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
2273   
2274 -    def __getfield_slot(self): 
2275          return self.__field_slot.getvalue() 
2276   
2277 -    def __setfield_slot(self, value): 
2278          if isinstance(value,UINT): 
2279              self.__field_slot=value 
2280          else: 
2281              self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 
2282   
2283 -    def __delfield_slot(self): del self.__field_slot 
2284   
2285      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
2286   
2287 -    def iscontainer(self): 
2288          return True 
2289   
2290 -    def containerelements(self): 
2291          yield ('header', self.__field_header, None) 
2292          yield ('slot', self.__field_slot, None) 
2293   
2294   
2295   
2296   
2297 -class emailupdaterequest(BaseProtogenClass): 
2298      __fields=['header', 'slot', 'entry'] 
2299   
2300 -    def __init__(self, *args, **kwargs): 
2301          dict={} 
2302          # What was supplied to this function 
2303          dict.update(kwargs) 
2304          # Parent constructor 
2305          super(emailupdaterequest,self).__init__(**dict) 
2306          if self.__class__ is emailupdaterequest: 
2307              self._update(args,dict) 
2308   
2309   
2310 -    def getfields(self): 
2311          return self.__fields 
2312   
2313   
2314 -    def _update(self, args, kwargs): 
2315          super(emailupdaterequest,self)._update(args,kwargs) 
2316          keys=kwargs.keys() 
2317          for key in keys: 
2318              if key in self.__fields: 
2319                  setattr(self, key, kwargs[key]) 
2320                  del kwargs[key] 
2321          # Were any unrecognized kwargs passed in? 
2322          if __debug__: 
2323              self._complainaboutunusedargs(emailupdaterequest,kwargs) 
2324          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2325          # Make all P fields that haven't already been constructed 
2326   
2327   
2328 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2329          'Writes this packet to the supplied buffer' 
2330          self._bufferstartoffset=buf.getcurrentoffset() 
2331          try: self.__field_header 
2332          except: 
2333              self.__field_header=sanyowriteheader(**{'packettype': 0xca,                   'command': 0x43}) 
2334          self.__field_header.writetobuffer(buf) 
2335          self.__field_slot.writetobuffer(buf) 
2336          try: self.__field_entry 
2337          except: 
2338              self.__field_entry=emailentry() 
2339          self.__field_entry.writetobuffer(buf) 
2340          self._bufferendoffset=buf.getcurrentoffset() 
2341          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2342   
2343   
2344 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2345          'Reads this packet from the supplied buffer' 
2346          self._bufferstartoffset=buf.getcurrentoffset() 
2347          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2348          self.__field_header=sanyowriteheader(**{'packettype': 0xca,                   'command': 0x43}) 
2349          self.__field_header.readfrombuffer(buf) 
2350          self.__field_slot=UINT(**{'sizeinbytes': 2}) 
2351          self.__field_slot.readfrombuffer(buf) 
2352          self.__field_entry=emailentry() 
2353          self.__field_entry.readfrombuffer(buf) 
2354          self._bufferendoffset=buf.getcurrentoffset() 
2355   
2356   
2357 -    def __getfield_header(self): 
2358          try: self.__field_header 
2359          except: 
2360              self.__field_header=sanyowriteheader(**{'packettype': 0xca,                   'command': 0x43}) 
2361          return self.__field_header.getvalue() 
2362   
2363 -    def __setfield_header(self, value): 
2364          if isinstance(value,sanyowriteheader): 
2365              self.__field_header=value 
2366          else: 
2367              self.__field_header=sanyowriteheader(value,**{'packettype': 0xca,                   'command': 0x43}) 
2368   
2369 -    def __delfield_header(self): del self.__field_header 
2370   
2371      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
2372   
2373 -    def __getfield_slot(self): 
2374          return self.__field_slot.getvalue() 
2375   
2376 -    def __setfield_slot(self, value): 
2377          if isinstance(value,UINT): 
2378              self.__field_slot=value 
2379          else: 
2380              self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 
2381   
2382 -    def __delfield_slot(self): del self.__field_slot 
2383   
2384      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
2385   
2386 -    def __getfield_entry(self): 
2387          try: self.__field_entry 
2388          except: 
2389              self.__field_entry=emailentry() 
2390          return self.__field_entry.getvalue() 
2391   
2392 -    def __setfield_entry(self, value): 
2393          if isinstance(value,emailentry): 
2394              self.__field_entry=value 
2395          else: 
2396              self.__field_entry=emailentry(value,) 
2397   
2398 -    def __delfield_entry(self): del self.__field_entry 
2399   
2400      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
2401   
2402 -    def iscontainer(self): 
2403          return True 
2404   
2405 -    def containerelements(self): 
2406          yield ('header', self.__field_header, None) 
2407          yield ('slot', self.__field_slot, None) 
2408          yield ('entry', self.__field_entry, None) 
2409   
2410   
2411   
2412   
2413 -class memorequest(BaseProtogenClass): 
2414      __fields=['header', 'slot'] 
2415   
2416 -    def __init__(self, *args, **kwargs): 
2417          dict={} 
2418          # What was supplied to this function 
2419          dict.update(kwargs) 
2420          # Parent constructor 
2421          super(memorequest,self).__init__(**dict) 
2422          if self.__class__ is memorequest: 
2423              self._update(args,dict) 
2424   
2425   
2426 -    def getfields(self): 
2427          return self.__fields 
2428   
2429   
2430 -    def _update(self, args, kwargs): 
2431          super(memorequest,self)._update(args,kwargs) 
2432          keys=kwargs.keys() 
2433          for key in keys: 
2434              if key in self.__fields: 
2435                  setattr(self, key, kwargs[key]) 
2436                  del kwargs[key] 
2437          # Were any unrecognized kwargs passed in? 
2438          if __debug__: 
2439              self._complainaboutunusedargs(memorequest,kwargs) 
2440          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2441          # Make all P fields that haven't already been constructed 
2442   
2443   
2444 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2445          'Writes this packet to the supplied buffer' 
2446          self._bufferstartoffset=buf.getcurrentoffset() 
2447          try: self.__field_header 
2448          except: 
2449              self.__field_header=sanyoheader(**{'packettype': 0xca,                   'command': 0x4e}) 
2450          self.__field_header.writetobuffer(buf) 
2451          self.__field_slot.writetobuffer(buf) 
2452          self._bufferendoffset=buf.getcurrentoffset() 
2453          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2454   
2455   
2456 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2457          'Reads this packet from the supplied buffer' 
2458          self._bufferstartoffset=buf.getcurrentoffset() 
2459          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2460          self.__field_header=sanyoheader(**{'packettype': 0xca,                   'command': 0x4e}) 
2461          self.__field_header.readfrombuffer(buf) 
2462          self.__field_slot=UINT(**{'sizeinbytes': 2}) 
2463          self.__field_slot.readfrombuffer(buf) 
2464          self._bufferendoffset=buf.getcurrentoffset() 
2465   
2466   
2467 -    def __getfield_header(self): 
2468          try: self.__field_header 
2469          except: 
2470              self.__field_header=sanyoheader(**{'packettype': 0xca,                   'command': 0x4e}) 
2471          return self.__field_header.getvalue() 
2472   
2473 -    def __setfield_header(self, value): 
2474          if isinstance(value,sanyoheader): 
2475              self.__field_header=value 
2476          else: 
2477              self.__field_header=sanyoheader(value,**{'packettype': 0xca,                   'command': 0x4e}) 
2478   
2479 -    def __delfield_header(self): del self.__field_header 
2480   
2481      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
2482   
2483 -    def __getfield_slot(self): 
2484          return self.__field_slot.getvalue() 
2485   
2486 -    def __setfield_slot(self, value): 
2487          if isinstance(value,UINT): 
2488              self.__field_slot=value 
2489          else: 
2490              self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 
2491   
2492 -    def __delfield_slot(self): del self.__field_slot 
2493   
2494      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
2495   
2496 -    def iscontainer(self): 
2497          return True 
2498   
2499 -    def containerelements(self): 
2500          yield ('header', self.__field_header, None) 
2501          yield ('slot', self.__field_slot, None) 
2502   
2503   
2504   
2505   
2506 -class memoupdaterequest(BaseProtogenClass): 
2507      __fields=['header', 'slot', 'entry'] 
2508   
2509 -    def __init__(self, *args, **kwargs): 
2510          dict={} 
2511          # What was supplied to this function 
2512          dict.update(kwargs) 
2513          # Parent constructor 
2514          super(memoupdaterequest,self).__init__(**dict) 
2515          if self.__class__ is memoupdaterequest: 
2516              self._update(args,dict) 
2517   
2518   
2519 -    def getfields(self): 
2520          return self.__fields 
2521   
2522   
2523 -    def _update(self, args, kwargs): 
2524          super(memoupdaterequest,self)._update(args,kwargs) 
2525          keys=kwargs.keys() 
2526          for key in keys: 
2527              if key in self.__fields: 
2528                  setattr(self, key, kwargs[key]) 
2529                  del kwargs[key] 
2530          # Were any unrecognized kwargs passed in? 
2531          if __debug__: 
2532              self._complainaboutunusedargs(memoupdaterequest,kwargs) 
2533          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2534          # Make all P fields that haven't already been constructed 
2535   
2536   
2537 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2538          'Writes this packet to the supplied buffer' 
2539          self._bufferstartoffset=buf.getcurrentoffset() 
2540          try: self.__field_header 
2541          except: 
2542              self.__field_header=sanyowriteheader(**{'packettype': 0xca,                   'command': 0x4e}) 
2543          self.__field_header.writetobuffer(buf) 
2544          self.__field_slot.writetobuffer(buf) 
2545          try: self.__field_entry 
2546          except: 
2547              self.__field_entry=memoentry() 
2548          self.__field_entry.writetobuffer(buf) 
2549          self._bufferendoffset=buf.getcurrentoffset() 
2550          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2551   
2552   
2553 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2554          'Reads this packet from the supplied buffer' 
2555          self._bufferstartoffset=buf.getcurrentoffset() 
2556          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2557          self.__field_header=sanyowriteheader(**{'packettype': 0xca,                   'command': 0x4e}) 
2558          self.__field_header.readfrombuffer(buf) 
2559          self.__field_slot=UINT(**{'sizeinbytes': 2}) 
2560          self.__field_slot.readfrombuffer(buf) 
2561          self.__field_entry=memoentry() 
2562          self.__field_entry.readfrombuffer(buf) 
2563          self._bufferendoffset=buf.getcurrentoffset() 
2564   
2565   
2566 -    def __getfield_header(self): 
2567          try: self.__field_header 
2568          except: 
2569              self.__field_header=sanyowriteheader(**{'packettype': 0xca,                   'command': 0x4e}) 
2570          return self.__field_header.getvalue() 
2571   
2572 -    def __setfield_header(self, value): 
2573          if isinstance(value,sanyowriteheader): 
2574              self.__field_header=value 
2575          else: 
2576              self.__field_header=sanyowriteheader(value,**{'packettype': 0xca,                   'command': 0x4e}) 
2577   
2578 -    def __delfield_header(self): del self.__field_header 
2579   
2580      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
2581   
2582 -    def __getfield_slot(self): 
2583          return self.__field_slot.getvalue() 
2584   
2585 -    def __setfield_slot(self, value): 
2586          if isinstance(value,UINT): 
2587              self.__field_slot=value 
2588          else: 
2589              self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 
2590   
2591 -    def __delfield_slot(self): del self.__field_slot 
2592   
2593      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
2594   
2595 -    def __getfield_entry(self): 
2596          try: self.__field_entry 
2597          except: 
2598              self.__field_entry=memoentry() 
2599          return self.__field_entry.getvalue() 
2600   
2601 -    def __setfield_entry(self, value): 
2602          if isinstance(value,memoentry): 
2603              self.__field_entry=value 
2604          else: 
2605              self.__field_entry=memoentry(value,) 
2606   
2607 -    def __delfield_entry(self): del self.__field_entry 
2608   
2609      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
2610   
2611 -    def iscontainer(self): 
2612          return True 
2613   
2614 -    def containerelements(self): 
2615          yield ('header', self.__field_header, None) 
2616          yield ('slot', self.__field_slot, None) 
2617          yield ('entry', self.__field_entry, None) 
2618   
2619   
2620   
2621   
2622 -class addressrequest(BaseProtogenClass): 
2623      __fields=['header', 'slot'] 
2624   
2625 -    def __init__(self, *args, **kwargs): 
2626          dict={} 
2627          # What was supplied to this function 
2628          dict.update(kwargs) 
2629          # Parent constructor 
2630          super(addressrequest,self).__init__(**dict) 
2631          if self.__class__ is addressrequest: 
2632              self._update(args,dict) 
2633   
2634   
2635 -    def getfields(self): 
2636          return self.__fields 
2637   
2638   
2639 -    def _update(self, args, kwargs): 
2640          super(addressrequest,self)._update(args,kwargs) 
2641          keys=kwargs.keys() 
2642          for key in keys: 
2643              if key in self.__fields: 
2644                  setattr(self, key, kwargs[key]) 
2645                  del kwargs[key] 
2646          # Were any unrecognized kwargs passed in? 
2647          if __debug__: 
2648              self._complainaboutunusedargs(addressrequest,kwargs) 
2649          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2650          # Make all P fields that haven't already been constructed 
2651   
2652   
2653 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2654          'Writes this packet to the supplied buffer' 
2655          self._bufferstartoffset=buf.getcurrentoffset() 
2656          try: self.__field_header 
2657          except: 
2658              self.__field_header=sanyoheader(**{'packettype': 0xca,                   'command': 0x4b}) 
2659          self.__field_header.writetobuffer(buf) 
2660          self.__field_slot.writetobuffer(buf) 
2661          self._bufferendoffset=buf.getcurrentoffset() 
2662          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2663   
2664   
2665 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2666          'Reads this packet from the supplied buffer' 
2667          self._bufferstartoffset=buf.getcurrentoffset() 
2668          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2669          self.__field_header=sanyoheader(**{'packettype': 0xca,                   'command': 0x4b}) 
2670          self.__field_header.readfrombuffer(buf) 
2671          self.__field_slot=UINT(**{'sizeinbytes': 2}) 
2672          self.__field_slot.readfrombuffer(buf) 
2673          self._bufferendoffset=buf.getcurrentoffset() 
2674   
2675   
2676 -    def __getfield_header(self): 
2677          try: self.__field_header 
2678          except: 
2679              self.__field_header=sanyoheader(**{'packettype': 0xca,                   'command': 0x4b}) 
2680          return self.__field_header.getvalue() 
2681   
2682 -    def __setfield_header(self, value): 
2683          if isinstance(value,sanyoheader): 
2684              self.__field_header=value 
2685          else: 
2686              self.__field_header=sanyoheader(value,**{'packettype': 0xca,                   'command': 0x4b}) 
2687   
2688 -    def __delfield_header(self): del self.__field_header 
2689   
2690      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
2691   
2692 -    def __getfield_slot(self): 
2693          return self.__field_slot.getvalue() 
2694   
2695 -    def __setfield_slot(self, value): 
2696          if isinstance(value,UINT): 
2697              self.__field_slot=value 
2698          else: 
2699              self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 
2700   
2701 -    def __delfield_slot(self): del self.__field_slot 
2702   
2703      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
2704   
2705 -    def iscontainer(self): 
2706          return True 
2707   
2708 -    def containerelements(self): 
2709          yield ('header', self.__field_header, None) 
2710          yield ('slot', self.__field_slot, None) 
2711   
2712   
2713   
2714   
2715 -class addressupdaterequest(BaseProtogenClass): 
2716      __fields=['header', 'slot', 'entry'] 
2717   
2718 -    def __init__(self, *args, **kwargs): 
2719          dict={} 
2720          # What was supplied to this function 
2721          dict.update(kwargs) 
2722          # Parent constructor 
2723          super(addressupdaterequest,self).__init__(**dict) 
2724          if self.__class__ is addressupdaterequest: 
2725              self._update(args,dict) 
2726   
2727   
2728 -    def getfields(self): 
2729          return self.__fields 
2730   
2731   
2732 -    def _update(self, args, kwargs): 
2733          super(addressupdaterequest,self)._update(args,kwargs) 
2734          keys=kwargs.keys() 
2735          for key in keys: 
2736              if key in self.__fields: 
2737                  setattr(self, key, kwargs[key]) 
2738                  del kwargs[key] 
2739          # Were any unrecognized kwargs passed in? 
2740          if __debug__: 
2741              self._complainaboutunusedargs(addressupdaterequest,kwargs) 
2742          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2743          # Make all P fields that haven't already been constructed 
2744   
2745   
2746 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2747          'Writes this packet to the supplied buffer' 
2748          self._bufferstartoffset=buf.getcurrentoffset() 
2749          try: self.__field_header 
2750          except: 
2751              self.__field_header=sanyowriteheader(**{'packettype': 0xca,                   'command': 0x4b}) 
2752          self.__field_header.writetobuffer(buf) 
2753          self.__field_slot.writetobuffer(buf) 
2754          try: self.__field_entry 
2755          except: 
2756              self.__field_entry=addressentry() 
2757          self.__field_entry.writetobuffer(buf) 
2758          self._bufferendoffset=buf.getcurrentoffset() 
2759          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2760   
2761   
2762 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2763          'Reads this packet from the supplied buffer' 
2764          self._bufferstartoffset=buf.getcurrentoffset() 
2765          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2766          self.__field_header=sanyowriteheader(**{'packettype': 0xca,                   'command': 0x4b}) 
2767          self.__field_header.readfrombuffer(buf) 
2768          self.__field_slot=UINT(**{'sizeinbytes': 2}) 
2769          self.__field_slot.readfrombuffer(buf) 
2770          self.__field_entry=addressentry() 
2771          self.__field_entry.readfrombuffer(buf) 
2772          self._bufferendoffset=buf.getcurrentoffset() 
2773   
2774   
2775 -    def __getfield_header(self): 
2776          try: self.__field_header 
2777          except: 
2778              self.__field_header=sanyowriteheader(**{'packettype': 0xca,                   'command': 0x4b}) 
2779          return self.__field_header.getvalue() 
2780   
2781 -    def __setfield_header(self, value): 
2782          if isinstance(value,sanyowriteheader): 
2783              self.__field_header=value 
2784          else: 
2785              self.__field_header=sanyowriteheader(value,**{'packettype': 0xca,                   'command': 0x4b}) 
2786   
2787 -    def __delfield_header(self): del self.__field_header 
2788   
2789      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
2790   
2791 -    def __getfield_slot(self): 
2792          return self.__field_slot.getvalue() 
2793   
2794 -    def __setfield_slot(self, value): 
2795          if isinstance(value,UINT): 
2796              self.__field_slot=value 
2797          else: 
2798              self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 
2799   
2800 -    def __delfield_slot(self): del self.__field_slot 
2801   
2802      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
2803   
2804 -    def __getfield_entry(self): 
2805          try: self.__field_entry 
2806          except: 
2807              self.__field_entry=addressentry() 
2808          return self.__field_entry.getvalue() 
2809   
2810 -    def __setfield_entry(self, value): 
2811          if isinstance(value,addressentry): 
2812              self.__field_entry=value 
2813          else: 
2814              self.__field_entry=addressentry(value,) 
2815   
2816 -    def __delfield_entry(self): del self.__field_entry 
2817   
2818      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
2819   
2820 -    def iscontainer(self): 
2821          return True 
2822   
2823 -    def containerelements(self): 
2824          yield ('header', self.__field_header, None) 
2825          yield ('slot', self.__field_slot, None) 
2826          yield ('entry', self.__field_entry, None) 
2827   
2828   
2829   
2830   
2831 -class urlrequest(BaseProtogenClass): 
2832      __fields=['header', 'slot'] 
2833   
2834 -    def __init__(self, *args, **kwargs): 
2835          dict={} 
2836          # What was supplied to this function 
2837          dict.update(kwargs) 
2838          # Parent constructor 
2839          super(urlrequest,self).__init__(**dict) 
2840          if self.__class__ is urlrequest: 
2841              self._update(args,dict) 
2842   
2843   
2844 -    def getfields(self): 
2845          return self.__fields 
2846   
2847   
2848 -    def _update(self, args, kwargs): 
2849          super(urlrequest,self)._update(args,kwargs) 
2850          keys=kwargs.keys() 
2851          for key in keys: 
2852              if key in self.__fields: 
2853                  setattr(self, key, kwargs[key]) 
2854                  del kwargs[key] 
2855          # Were any unrecognized kwargs passed in? 
2856          if __debug__: 
2857              self._complainaboutunusedargs(urlrequest,kwargs) 
2858          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2859          # Make all P fields that haven't already been constructed 
2860   
2861   
2862 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2863          'Writes this packet to the supplied buffer' 
2864          self._bufferstartoffset=buf.getcurrentoffset() 
2865          try: self.__field_header 
2866          except: 
2867              self.__field_header=sanyoheader(**{'packettype': 0xca,                   'command': 0x48}) 
2868          self.__field_header.writetobuffer(buf) 
2869          self.__field_slot.writetobuffer(buf) 
2870          self._bufferendoffset=buf.getcurrentoffset() 
2871          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2872   
2873   
2874 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2875          'Reads this packet from the supplied buffer' 
2876          self._bufferstartoffset=buf.getcurrentoffset() 
2877          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2878          self.__field_header=sanyoheader(**{'packettype': 0xca,                   'command': 0x48}) 
2879          self.__field_header.readfrombuffer(buf) 
2880          self.__field_slot=UINT(**{'sizeinbytes': 2}) 
2881          self.__field_slot.readfrombuffer(buf) 
2882          self._bufferendoffset=buf.getcurrentoffset() 
2883   
2884   
2885 -    def __getfield_header(self): 
2886          try: self.__field_header 
2887          except: 
2888              self.__field_header=sanyoheader(**{'packettype': 0xca,                   'command': 0x48}) 
2889          return self.__field_header.getvalue() 
2890   
2891 -    def __setfield_header(self, value): 
2892          if isinstance(value,sanyoheader): 
2893              self.__field_header=value 
2894          else: 
2895              self.__field_header=sanyoheader(value,**{'packettype': 0xca,                   'command': 0x48}) 
2896   
2897 -    def __delfield_header(self): del self.__field_header 
2898   
2899      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
2900   
2901 -    def __getfield_slot(self): 
2902          return self.__field_slot.getvalue() 
2903   
2904 -    def __setfield_slot(self, value): 
2905          if isinstance(value,UINT): 
2906              self.__field_slot=value 
2907          else: 
2908              self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 
2909   
2910 -    def __delfield_slot(self): del self.__field_slot 
2911   
2912      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
2913   
2914 -    def iscontainer(self): 
2915          return True 
2916   
2917 -    def containerelements(self): 
2918          yield ('header', self.__field_header, None) 
2919          yield ('slot', self.__field_slot, None) 
2920   
2921   
2922   
2923   
2924 -class urlupdaterequest(BaseProtogenClass): 
2925      __fields=['header', 'slot', 'entry'] 
2926   
2927 -    def __init__(self, *args, **kwargs): 
2928          dict={} 
2929          # What was supplied to this function 
2930          dict.update(kwargs) 
2931          # Parent constructor 
2932          super(urlupdaterequest,self).__init__(**dict) 
2933          if self.__class__ is urlupdaterequest: 
2934              self._update(args,dict) 
2935   
2936   
2937 -    def getfields(self): 
2938          return self.__fields 
2939   
2940   
2941 -    def _update(self, args, kwargs): 
2942          super(urlupdaterequest,self)._update(args,kwargs) 
2943          keys=kwargs.keys() 
2944          for key in keys: 
2945              if key in self.__fields: 
2946                  setattr(self, key, kwargs[key]) 
2947                  del kwargs[key] 
2948          # Were any unrecognized kwargs passed in? 
2949          if __debug__: 
2950              self._complainaboutunusedargs(urlupdaterequest,kwargs) 
2951          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2952          # Make all P fields that haven't already been constructed 
2953   
2954   
2955 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2956          'Writes this packet to the supplied buffer' 
2957          self._bufferstartoffset=buf.getcurrentoffset() 
2958          try: self.__field_header 
2959          except: 
2960              self.__field_header=sanyowriteheader(**{'packettype': 0xca,                   'command': 0x48}) 
2961          self.__field_header.writetobuffer(buf) 
2962          self.__field_slot.writetobuffer(buf) 
2963          try: self.__field_entry 
2964          except: 
2965              self.__field_entry=urlentry() 
2966          self.__field_entry.writetobuffer(buf) 
2967          self._bufferendoffset=buf.getcurrentoffset() 
2968          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2969   
2970   
2971 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2972          'Reads this packet from the supplied buffer' 
2973          self._bufferstartoffset=buf.getcurrentoffset() 
2974          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2975          self.__field_header=sanyowriteheader(**{'packettype': 0xca,                   'command': 0x48}) 
2976          self.__field_header.readfrombuffer(buf) 
2977          self.__field_slot=UINT(**{'sizeinbytes': 2}) 
2978          self.__field_slot.readfrombuffer(buf) 
2979          self.__field_entry=urlentry() 
2980          self.__field_entry.readfrombuffer(buf) 
2981          self._bufferendoffset=buf.getcurrentoffset() 
2982   
2983   
2984 -    def __getfield_header(self): 
2985          try: self.__field_header 
2986          except: 
2987              self.__field_header=sanyowriteheader(**{'packettype': 0xca,                   'command': 0x48}) 
2988          return self.__field_header.getvalue() 
2989   
2990 -    def __setfield_header(self, value): 
2991          if isinstance(value,sanyowriteheader): 
2992              self.__field_header=value 
2993          else: 
2994              self.__field_header=sanyowriteheader(value,**{'packettype': 0xca,                   'command': 0x48}) 
2995   
2996 -    def __delfield_header(self): del self.__field_header 
2997   
2998      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
2999   
3000 -    def __getfield_slot(self): 
3001          return self.__field_slot.getvalue() 
3002   
3003 -    def __setfield_slot(self, value): 
3004          if isinstance(value,UINT): 
3005              self.__field_slot=value 
3006          else: 
3007              self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 
3008   
3009 -    def __delfield_slot(self): del self.__field_slot 
3010   
3011      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
3012   
3013 -    def __getfield_entry(self): 
3014          try: self.__field_entry 
3015          except: 
3016              self.__field_entry=urlentry() 
3017          return self.__field_entry.getvalue() 
3018   
3019 -    def __setfield_entry(self, value): 
3020          if isinstance(value,urlentry): 
3021              self.__field_entry=value 
3022          else: 
3023              self.__field_entry=urlentry(value,) 
3024   
3025 -    def __delfield_entry(self): del self.__field_entry 
3026   
3027      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
3028   
3029 -    def iscontainer(self): 
3030          return True 
3031   
3032 -    def containerelements(self): 
3033          yield ('header', self.__field_header, None) 
3034          yield ('slot', self.__field_slot, None) 
3035          yield ('entry', self.__field_entry, None) 
3036   
3037   
3038   
3039   
3040 -class grouprequest(BaseProtogenClass): 
3041      __fields=['header', 'slot'] 
3042   
3043 -    def __init__(self, *args, **kwargs): 
3044          dict={} 
3045          # What was supplied to this function 
3046          dict.update(kwargs) 
3047          # Parent constructor 
3048          super(grouprequest,self).__init__(**dict) 
3049          if self.__class__ is grouprequest: 
3050              self._update(args,dict) 
3051   
3052   
3053 -    def getfields(self): 
3054          return self.__fields 
3055   
3056   
3057 -    def _update(self, args, kwargs): 
3058          super(grouprequest,self)._update(args,kwargs) 
3059          keys=kwargs.keys() 
3060          for key in keys: 
3061              if key in self.__fields: 
3062                  setattr(self, key, kwargs[key]) 
3063                  del kwargs[key] 
3064          # Were any unrecognized kwargs passed in? 
3065          if __debug__: 
3066              self._complainaboutunusedargs(grouprequest,kwargs) 
3067          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
3068          # Make all P fields that haven't already been constructed 
3069   
3070   
3071 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3072          'Writes this packet to the supplied buffer' 
3073          self._bufferstartoffset=buf.getcurrentoffset() 
3074          try: self.__field_header 
3075          except: 
3076              self.__field_header=sanyoheader(**{'packettype': 0xca,                   'command': 0x37}) 
3077          self.__field_header.writetobuffer(buf) 
3078          self.__field_slot.writetobuffer(buf) 
3079          self._bufferendoffset=buf.getcurrentoffset() 
3080          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3081   
3082   
3083 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3084          'Reads this packet from the supplied buffer' 
3085          self._bufferstartoffset=buf.getcurrentoffset() 
3086          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3087          self.__field_header=sanyoheader(**{'packettype': 0xca,                   'command': 0x37}) 
3088          self.__field_header.readfrombuffer(buf) 
3089          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
3090          self.__field_slot.readfrombuffer(buf) 
3091          self._bufferendoffset=buf.getcurrentoffset() 
3092   
3093   
3094 -    def __getfield_header(self): 
3095          try: self.__field_header 
3096          except: 
3097              self.__field_header=sanyoheader(**{'packettype': 0xca,                   'command': 0x37}) 
3098          return self.__field_header.getvalue() 
3099   
3100 -    def __setfield_header(self, value): 
3101          if isinstance(value,sanyoheader): 
3102              self.__field_header=value 
3103          else: 
3104              self.__field_header=sanyoheader(value,**{'packettype': 0xca,                   'command': 0x37}) 
3105   
3106 -    def __delfield_header(self): del self.__field_header 
3107   
3108      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
3109   
3110 -    def __getfield_slot(self): 
3111          return self.__field_slot.getvalue() 
3112   
3113 -    def __setfield_slot(self, value): 
3114          if isinstance(value,UINT): 
3115              self.__field_slot=value 
3116          else: 
3117              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
3118   
3119 -    def __delfield_slot(self): del self.__field_slot 
3120   
3121      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
3122   
3123 -    def iscontainer(self): 
3124          return True 
3125   
3126 -    def containerelements(self): 
3127          yield ('header', self.__field_header, None) 
3128          yield ('slot', self.__field_slot, None) 
3129   
3130   
3131   
3132   
3133 -class groupupdaterequest(BaseProtogenClass): 
3134      __fields=['header', 'slot', 'entry', 'pad'] 
3135   
3136 -    def __init__(self, *args, **kwargs): 
3137          dict={} 
3138          # What was supplied to this function 
3139          dict.update(kwargs) 
3140          # Parent constructor 
3141          super(groupupdaterequest,self).__init__(**dict) 
3142          if self.__class__ is groupupdaterequest: 
3143              self._update(args,dict) 
3144   
3145   
3146 -    def getfields(self): 
3147          return self.__fields 
3148   
3149   
3150 -    def _update(self, args, kwargs): 
3151          super(groupupdaterequest,self)._update(args,kwargs) 
3152          keys=kwargs.keys() 
3153          for key in keys: 
3154              if key in self.__fields: 
3155                  setattr(self, key, kwargs[key]) 
3156                  del kwargs[key] 
3157          # Were any unrecognized kwargs passed in? 
3158          if __debug__: 
3159              self._complainaboutunusedargs(groupupdaterequest,kwargs) 
3160          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
3161          # Make all P fields that haven't already been constructed 
3162   
3163   
3164 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3165          'Writes this packet to the supplied buffer' 
3166          self._bufferstartoffset=buf.getcurrentoffset() 
3167          try: self.__field_header 
3168          except: 
3169              self.__field_header=sanyowriteheader(**{'packettype': 0xca,                   'command': 0x37}) 
3170          self.__field_header.writetobuffer(buf) 
3171          self.__field_slot.writetobuffer(buf) 
3172          self.__field_entry.writetobuffer(buf) 
3173          self.__field_pad.writetobuffer(buf) 
3174          self._bufferendoffset=buf.getcurrentoffset() 
3175          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3176   
3177   
3178 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3179          'Reads this packet from the supplied buffer' 
3180          self._bufferstartoffset=buf.getcurrentoffset() 
3181          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3182          self.__field_header=sanyowriteheader(**{'packettype': 0xca,                   'command': 0x37}) 
3183          self.__field_header.readfrombuffer(buf) 
3184          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
3185          self.__field_slot.readfrombuffer(buf) 
3186          self.__field_entry=groupentry() 
3187          self.__field_entry.readfrombuffer(buf) 
3188          self.__field_pad=UNKNOWN() 
3189          self.__field_pad.readfrombuffer(buf) 
3190          self._bufferendoffset=buf.getcurrentoffset() 
3191   
3192   
3193 -    def __getfield_header(self): 
3194          try: self.__field_header 
3195          except: 
3196              self.__field_header=sanyowriteheader(**{'packettype': 0xca,                   'command': 0x37}) 
3197          return self.__field_header.getvalue() 
3198   
3199 -    def __setfield_header(self, value): 
3200          if isinstance(value,sanyowriteheader): 
3201              self.__field_header=value 
3202          else: 
3203              self.__field_header=sanyowriteheader(value,**{'packettype': 0xca,                   'command': 0x37}) 
3204   
3205 -    def __delfield_header(self): del self.__field_header 
3206   
3207      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
3208   
3209 -    def __getfield_slot(self): 
3210          return self.__field_slot.getvalue() 
3211   
3212 -    def __setfield_slot(self, value): 
3213          if isinstance(value,UINT): 
3214              self.__field_slot=value 
3215          else: 
3216              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
3217   
3218 -    def __delfield_slot(self): del self.__field_slot 
3219   
3220      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
3221   
3222 -    def __getfield_entry(self): 
3223          return self.__field_entry.getvalue() 
3224   
3225 -    def __setfield_entry(self, value): 
3226          if isinstance(value,groupentry): 
3227              self.__field_entry=value 
3228          else: 
3229              self.__field_entry=groupentry(value,) 
3230   
3231 -    def __delfield_entry(self): del self.__field_entry 
3232   
3233      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
3234   
3235 -    def __getfield_pad(self): 
3236          return self.__field_pad.getvalue() 
3237   
3238 -    def __setfield_pad(self, value): 
3239          if isinstance(value,UNKNOWN): 
3240              self.__field_pad=value 
3241          else: 
3242              self.__field_pad=UNKNOWN(value,) 
3243   
3244 -    def __delfield_pad(self): del self.__field_pad 
3245   
3246      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
3247   
3248 -    def iscontainer(self): 
3249          return True 
3250   
3251 -    def containerelements(self): 
3252          yield ('header', self.__field_header, None) 
3253          yield ('slot', self.__field_slot, None) 
3254          yield ('entry', self.__field_entry, None) 
3255          yield ('pad', self.__field_pad, None) 
3256   
3257   
3258   
3259   
3260 -class sanyoreset(BaseProtogenClass): 
3261      __fields=['preamble', 'command', 'packettype'] 
3262   
3263 -    def __init__(self, *args, **kwargs): 
3264          dict={} 
3265          # What was supplied to this function 
3266          dict.update(kwargs) 
3267          # Parent constructor 
3268          super(sanyoreset,self).__init__(**dict) 
3269          if self.__class__ is sanyoreset: 
3270              self._update(args,dict) 
3271   
3272   
3273 -    def getfields(self): 
3274          return self.__fields 
3275   
3276   
3277 -    def _update(self, args, kwargs): 
3278          super(sanyoreset,self)._update(args,kwargs) 
3279          keys=kwargs.keys() 
3280          for key in keys: 
3281              if key in self.__fields: 
3282                  setattr(self, key, kwargs[key]) 
3283                  del kwargs[key] 
3284          # Were any unrecognized kwargs passed in? 
3285          if __debug__: 
3286              self._complainaboutunusedargs(sanyoreset,kwargs) 
3287          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
3288          # Make all P fields that haven't already been constructed 
3289   
3290   
3291 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3292          'Writes this packet to the supplied buffer' 
3293          self._bufferstartoffset=buf.getcurrentoffset() 
3294          try: self.__field_preamble 
3295          except: 
3296              self.__field_preamble=sanyofaheader(**{'faset': 0x37}) 
3297          self.__field_preamble.writetobuffer(buf) 
3298          try: self.__field_command 
3299          except: 
3300              self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0}) 
3301          self.__field_command.writetobuffer(buf) 
3302          try: self.__field_packettype 
3303          except: 
3304              self.__field_packettype=UINT(**{'sizeinbytes': 1, 'constant': 0}) 
3305          self.__field_packettype.writetobuffer(buf) 
3306          self._bufferendoffset=buf.getcurrentoffset() 
3307          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3308   
3309   
3310 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3311          'Reads this packet from the supplied buffer' 
3312          self._bufferstartoffset=buf.getcurrentoffset() 
3313          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3314          self.__field_preamble=sanyofaheader(**{'faset': 0x37}) 
3315          self.__field_preamble.readfrombuffer(buf) 
3316          self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0}) 
3317          self.__field_command.readfrombuffer(buf) 
3318          self.__field_packettype=UINT(**{'sizeinbytes': 1, 'constant': 0}) 
3319          self.__field_packettype.readfrombuffer(buf) 
3320          self._bufferendoffset=buf.getcurrentoffset() 
3321   
3322   
3323 -    def __getfield_preamble(self): 
3324          try: self.__field_preamble 
3325          except: 
3326              self.__field_preamble=sanyofaheader(**{'faset': 0x37}) 
3327          return self.__field_preamble.getvalue() 
3328   
3329 -    def __setfield_preamble(self, value): 
3330          if isinstance(value,sanyofaheader): 
3331              self.__field_preamble=value 
3332          else: 
3333              self.__field_preamble=sanyofaheader(value,**{'faset': 0x37}) 
3334   
3335 -    def __delfield_preamble(self): del self.__field_preamble 
3336   
3337      preamble=property(__getfield_preamble, __setfield_preamble, __delfield_preamble, None) 
3338   
3339 -    def __getfield_command(self): 
3340          try: self.__field_command 
3341          except: 
3342              self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0}) 
3343          return self.__field_command.getvalue() 
3344   
3345 -    def __setfield_command(self, value): 
3346          if isinstance(value,UINT): 
3347              self.__field_command=value 
3348          else: 
3349              self.__field_command=UINT(value,**{'sizeinbytes': 1, 'constant': 0}) 
3350   
3351 -    def __delfield_command(self): del self.__field_command 
3352   
3353      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
3354   
3355 -    def __getfield_packettype(self): 
3356          try: self.__field_packettype 
3357          except: 
3358              self.__field_packettype=UINT(**{'sizeinbytes': 1, 'constant': 0}) 
3359          return self.__field_packettype.getvalue() 
3360   
3361 -    def __setfield_packettype(self, value): 
3362          if isinstance(value,UINT): 
3363              self.__field_packettype=value 
3364          else: 
3365              self.__field_packettype=UINT(value,**{'sizeinbytes': 1, 'constant': 0}) 
3366   
3367 -    def __delfield_packettype(self): del self.__field_packettype 
3368   
3369      packettype=property(__getfield_packettype, __setfield_packettype, __delfield_packettype, None) 
3370   
3371 -    def iscontainer(self): 
3372          return True 
3373   
3374 -    def containerelements(self): 
3375          yield ('preamble', self.__field_preamble, None) 
3376          yield ('command', self.__field_command, None) 
3377          yield ('packettype', self.__field_packettype, None) 
3378