Source Code for Module phones.p_sanyo6600

   1  # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE 
   2   
   3  """Various descriptions of data specific to Sanyo Katana (SCP-6600)""" 
   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   
  13  # We use LSB for all integer like fields 
  14  UINT=UINTlsb 
  15  BOOL=BOOLlsb 
  16  NUMPHONEBOOKENTRIES=500 
  17  MAXNUMBERS=700 
  18  MAXEMAILS=1000 
  19  MAXURLS=500 
  20  MAXMEMOS=500 
  21  MAXADDRESSES=500 
  22  _NUMSPEEDDIALS=8 
  23  _NUMLONGNUMBERS=5 
  24  _LONGPHONENUMBERLEN=30 
  25  _NUMEVENTSLOTS=100 
  26  _NUMCALLALARMSLOTS=15 
  27   # Need to check.  Is max phone will hold 32/96 or 33/97 
  28  MAXNUMBERLEN=48 
  29  MAXEMAILLEN=96 
  30  MAXURLLEN=96 
  31  MAXMEMOLEN=96 
  32  HASRINGPICBUF=0 
  33  NUMGROUPS=20 
  34  NUMPHONENUMBERS=7 
  35  NUMEMAILS=2 
  36  FIRSTSPEEDDIAL=2 
  37  LASTSPEEDDIAL=9 
  38   
  39   
  40 -class historyresponse(BaseProtogenClass): 
  41      __fields=['header', 'entry', 'pad'] 
  42   
  43 -    def __init__(self, *args, **kwargs): 
  44          dict={} 
  45          # What was supplied to this function 
  46          dict.update(kwargs) 
  47          # Parent constructor 
  48          super(historyresponse,self).__init__(**dict) 
  49          if self.__class__ is historyresponse: 
  50              self._update(args,dict) 
  51   
  52   
  53 -    def getfields(self): 
  54          return self.__fields 
  55   
  56   
  57 -    def _update(self, args, kwargs): 
  58          super(historyresponse,self)._update(args,kwargs) 
  59          keys=kwargs.keys() 
  60          for key in keys: 
  61              if key in self.__fields: 
  62                  setattr(self, key, kwargs[key]) 
  63                  del kwargs[key] 
  64          # Were any unrecognized kwargs passed in? 
  65          if __debug__: 
  66              self._complainaboutunusedargs(historyresponse,kwargs) 
  67          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
  68          # Make all P fields that haven't already been constructed 
  69   
  70   
  71 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
  72          'Writes this packet to the supplied buffer' 
  73          self._bufferstartoffset=buf.getcurrentoffset() 
  74          self.__field_header.writetobuffer(buf) 
  75          self.__field_entry.writetobuffer(buf) 
  76          self.__field_pad.writetobuffer(buf) 
  77          self._bufferendoffset=buf.getcurrentoffset() 
  78          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
  79   
  80   
  81 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
  82          'Reads this packet from the supplied buffer' 
  83          self._bufferstartoffset=buf.getcurrentoffset() 
  84          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
  85          self.__field_header=sanyoheader() 
  86          self.__field_header.readfrombuffer(buf) 
  87          self.__field_entry=historyentry() 
  88          self.__field_entry.readfrombuffer(buf) 
  89          self.__field_pad=UNKNOWN(**{'sizeinbytes': 428}) 
  90          self.__field_pad.readfrombuffer(buf) 
  91          self._bufferendoffset=buf.getcurrentoffset() 
  92   
  93   
  94 -    def __getfield_header(self): 
  95          return self.__field_header.getvalue() 
  96   
  97 -    def __setfield_header(self, value): 
  98          if isinstance(value,sanyoheader): 
  99              self.__field_header=value 
 100          else: 
 101              self.__field_header=sanyoheader(value,) 
 102   
 103 -    def __delfield_header(self): del self.__field_header 
 104   
 105      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
 106   
 107 -    def __getfield_entry(self): 
 108          return self.__field_entry.getvalue() 
 109   
 110 -    def __setfield_entry(self, value): 
 111          if isinstance(value,historyentry): 
 112              self.__field_entry=value 
 113          else: 
 114              self.__field_entry=historyentry(value,) 
 115   
 116 -    def __delfield_entry(self): del self.__field_entry 
 117   
 118      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
 119   
 120 -    def __getfield_pad(self): 
 121          return self.__field_pad.getvalue() 
 122   
 123 -    def __setfield_pad(self, value): 
 124          if isinstance(value,UNKNOWN): 
 125              self.__field_pad=value 
 126          else: 
 127              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 428}) 
 128   
 129 -    def __delfield_pad(self): del self.__field_pad 
 130   
 131      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
 132   
 133 -    def iscontainer(self): 
 134          return True 
 135   
 136 -    def containerelements(self): 
 137          yield ('header', self.__field_header, None) 
 138          yield ('entry', self.__field_entry, None) 
 139          yield ('pad', self.__field_pad, None) 
 140   
 141   
 142   
 143   
 144 -class historyentry(BaseProtogenClass): 
 145      __fields=['slot', 'date', 'phonenumlen', 'phonenum', 'name', 'dunno2', 'dunno3'] 
 146   
 147 -    def __init__(self, *args, **kwargs): 
 148          dict={} 
 149          # What was supplied to this function 
 150          dict.update(kwargs) 
 151          # Parent constructor 
 152          super(historyentry,self).__init__(**dict) 
 153          if self.__class__ is historyentry: 
 154              self._update(args,dict) 
 155   
 156   
 157 -    def getfields(self): 
 158          return self.__fields 
 159   
 160   
 161 -    def _update(self, args, kwargs): 
 162          super(historyentry,self)._update(args,kwargs) 
 163          keys=kwargs.keys() 
 164          for key in keys: 
 165              if key in self.__fields: 
 166                  setattr(self, key, kwargs[key]) 
 167                  del kwargs[key] 
 168          # Were any unrecognized kwargs passed in? 
 169          if __debug__: 
 170              self._complainaboutunusedargs(historyentry,kwargs) 
 171          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 172          # Make all P fields that haven't already been constructed 
 173   
 174   
 175 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 176          'Writes this packet to the supplied buffer' 
 177          self._bufferstartoffset=buf.getcurrentoffset() 
 178          self.__field_slot.writetobuffer(buf) 
 179          self.__field_date.writetobuffer(buf) 
 180          self.__field_phonenumlen.writetobuffer(buf) 
 181          self.__field_phonenum.writetobuffer(buf) 
 182          self.__field_name.writetobuffer(buf) 
 183          self.__field_dunno2.writetobuffer(buf) 
 184          self.__field_dunno3.writetobuffer(buf) 
 185          self._bufferendoffset=buf.getcurrentoffset() 
 186          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 187   
 188   
 189 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 190          'Reads this packet from the supplied buffer' 
 191          self._bufferstartoffset=buf.getcurrentoffset() 
 192          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 193          self.__field_slot=UINT(**{'sizeinbytes': 2}) 
 194          self.__field_slot.readfrombuffer(buf) 
 195          self.__field_date=GPSDATE(**{'sizeinbytes': 4}) 
 196          self.__field_date.readfrombuffer(buf) 
 197          self.__field_phonenumlen=UINT(**{'sizeinbytes': 1}) 
 198          self.__field_phonenumlen.readfrombuffer(buf) 
 199          self.__field_phonenum=USTRING(**{'sizeinbytes': 48, 'raiseonunterminatedread': False}) 
 200          self.__field_phonenum.readfrombuffer(buf) 
 201          self.__field_name=USTRING(**{'sizeinbytes': 16, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
 202          self.__field_name.readfrombuffer(buf) 
 203          self.__field_dunno2=UNKNOWN(**{'sizeinbytes': 1}) 
 204          self.__field_dunno2.readfrombuffer(buf) 
 205          self.__field_dunno3=UNKNOWN(**{'sizeinbytes': 1}) 
 206          self.__field_dunno3.readfrombuffer(buf) 
 207          self._bufferendoffset=buf.getcurrentoffset() 
 208   
 209   
 210 -    def __getfield_slot(self): 
 211          return self.__field_slot.getvalue() 
 212   
 213 -    def __setfield_slot(self, value): 
 214          if isinstance(value,UINT): 
 215              self.__field_slot=value 
 216          else: 
 217              self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 
 218   
 219 -    def __delfield_slot(self): del self.__field_slot 
 220   
 221      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
 222   
 223 -    def __getfield_date(self): 
 224          return self.__field_date.getvalue() 
 225   
 226 -    def __setfield_date(self, value): 
 227          if isinstance(value,GPSDATE): 
 228              self.__field_date=value 
 229          else: 
 230              self.__field_date=GPSDATE(value,**{'sizeinbytes': 4}) 
 231   
 232 -    def __delfield_date(self): del self.__field_date 
 233   
 234      date=property(__getfield_date, __setfield_date, __delfield_date, None) 
 235   
 236 -    def __getfield_phonenumlen(self): 
 237          return self.__field_phonenumlen.getvalue() 
 238   
 239 -    def __setfield_phonenumlen(self, value): 
 240          if isinstance(value,UINT): 
 241              self.__field_phonenumlen=value 
 242          else: 
 243              self.__field_phonenumlen=UINT(value,**{'sizeinbytes': 1}) 
 244   
 245 -    def __delfield_phonenumlen(self): del self.__field_phonenumlen 
 246   
 247      phonenumlen=property(__getfield_phonenumlen, __setfield_phonenumlen, __delfield_phonenumlen, None) 
 248   
 249 -    def __getfield_phonenum(self): 
 250          return self.__field_phonenum.getvalue() 
 251   
 252 -    def __setfield_phonenum(self, value): 
 253          if isinstance(value,USTRING): 
 254              self.__field_phonenum=value 
 255          else: 
 256              self.__field_phonenum=USTRING(value,**{'sizeinbytes': 48, 'raiseonunterminatedread': False}) 
 257   
 258 -    def __delfield_phonenum(self): del self.__field_phonenum 
 259   
 260      phonenum=property(__getfield_phonenum, __setfield_phonenum, __delfield_phonenum, None) 
 261   
 262 -    def __getfield_name(self): 
 263          return self.__field_name.getvalue() 
 264   
 265 -    def __setfield_name(self, value): 
 266          if isinstance(value,USTRING): 
 267              self.__field_name=value 
 268          else: 
 269              self.__field_name=USTRING(value,**{'sizeinbytes': 16, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
 270   
 271 -    def __delfield_name(self): del self.__field_name 
 272   
 273      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
 274   
 275 -    def __getfield_dunno2(self): 
 276          return self.__field_dunno2.getvalue() 
 277   
 278 -    def __setfield_dunno2(self, value): 
 279          if isinstance(value,UNKNOWN): 
 280              self.__field_dunno2=value 
 281          else: 
 282              self.__field_dunno2=UNKNOWN(value,**{'sizeinbytes': 1}) 
 283   
 284 -    def __delfield_dunno2(self): del self.__field_dunno2 
 285   
 286      dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None) 
 287   
 288 -    def __getfield_dunno3(self): 
 289          return self.__field_dunno3.getvalue() 
 290   
 291 -    def __setfield_dunno3(self, value): 
 292          if isinstance(value,UNKNOWN): 
 293              self.__field_dunno3=value 
 294          else: 
 295              self.__field_dunno3=UNKNOWN(value,**{'sizeinbytes': 1}) 
 296   
 297 -    def __delfield_dunno3(self): del self.__field_dunno3 
 298   
 299      dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None) 
 300   
 301 -    def iscontainer(self): 
 302          return True 
 303   
 304 -    def containerelements(self): 
 305          yield ('slot', self.__field_slot, None) 
 306          yield ('date', self.__field_date, None) 
 307          yield ('phonenumlen', self.__field_phonenumlen, None) 
 308          yield ('phonenum', self.__field_phonenum, None) 
 309          yield ('name', self.__field_name, None) 
 310          yield ('dunno2', self.__field_dunno2, None) 
 311          yield ('dunno3', self.__field_dunno3, None) 
 312   
 313   
 314   
 315   
 316 -class pbsortbuffer(BaseProtogenClass): 
 317      "Various arrays for sorting the phone book, speed dial, determining which" 
 318      __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'] 
 319   
 320 -    def __init__(self, *args, **kwargs): 
 321          dict={} 
 322          # What was supplied to this function 
 323          dict.update(kwargs) 
 324          # Parent constructor 
 325          super(pbsortbuffer,self).__init__(**dict) 
 326          if self.__class__ is pbsortbuffer: 
 327              self._update(args,dict) 
 328   
 329   
 330 -    def getfields(self): 
 331          return self.__fields 
 332   
 333   
 334 -    def _update(self, args, kwargs): 
 335          super(pbsortbuffer,self)._update(args,kwargs) 
 336          keys=kwargs.keys() 
 337          for key in keys: 
 338              if key in self.__fields: 
 339                  setattr(self, key, kwargs[key]) 
 340                  del kwargs[key] 
 341          # Were any unrecognized kwargs passed in? 
 342          if __debug__: 
 343              self._complainaboutunusedargs(pbsortbuffer,kwargs) 
 344          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 345          # Make all P fields that haven't already been constructed 
 346          try: self.__field_startcommand 
 347          except: 
 348              self.__field_startcommand=UINT(**{'constant': 0x76}) 
 349          try: self.__field_bufsize 
 350          except: 
 351              self.__field_bufsize=UINT(**{'constant': 6144}) 
 352          try: self.__field_comment 
 353          except: 
 354              self.__field_comment=USTRING(**{'default': "sort buffer"}) 
 355   
 356   
 357 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 358          'Writes this packet to the supplied buffer' 
 359          self._bufferstartoffset=buf.getcurrentoffset() 
 360          self.__field_groupslotsused.writetobuffer(buf) 
 361          try: self.__field_pad 
 362          except: 
 363              self.__field_pad=UNKNOWN(**{'sizeinbytes': 2}) 
 364          self.__field_pad.writetobuffer(buf) 
 365          try: self.__field_groupslotusedflags 
 366          except: 
 367              self.__field_groupslotusedflags=LIST(**{'elementclass': _gen_p_sanyo6600_79, 'length': NUMGROUPS, 'createdefault': True}) 
 368          self.__field_groupslotusedflags.writetobuffer(buf) 
 369          self.__field_slotsused.writetobuffer(buf) 
 370          try: self.__field_usedflags 
 371          except: 
 372              self.__field_usedflags=LIST(**{'elementclass': _gen_p_sanyo6600_83, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 
 373          self.__field_usedflags.writetobuffer(buf) 
 374          try: self.__field_speeddialindex 
 375          except: 
 376              self.__field_speeddialindex=LIST(**{'elementclass': _gen_p_sanyo6600_85, 'length': _NUMSPEEDDIALS}) 
 377          self.__field_speeddialindex.writetobuffer(buf) 
 378          self.__field_nameslotsused.writetobuffer(buf) 
 379          try: self.__field_nameusedflags 
 380          except: 
 381              self.__field_nameusedflags=LIST(**{'elementclass': _gen_p_sanyo6600_89, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 
 382          self.__field_nameusedflags.writetobuffer(buf) 
 383          try: self.__field_sortorder 
 384          except: 
 385              self.__field_sortorder=LIST(**{'elementclass': _gen_p_sanyo6600_91, 'length': NUMPHONEBOOKENTRIES}) 
 386          self.__field_sortorder.writetobuffer(buf) 
 387          self.__field_pbfirstletters.writetobuffer(buf) 
 388          self.__field_numslotsused.writetobuffer(buf) 
 389          try: self.__field_numusedflags 
 390          except: 
 391              self.__field_numusedflags=LIST(**{'elementclass': _gen_p_sanyo6600_96, 'length': MAXNUMBERS, 'createdefault': True}) 
 392          self.__field_numusedflags.writetobuffer(buf) 
 393          self.__field_emailslotsused.writetobuffer(buf) 
 394          try: self.__field_emailusedflags 
 395          except: 
 396              self.__field_emailusedflags=LIST(**{'elementclass': _gen_p_sanyo6600_100, 'length': MAXEMAILS, 'createdefault': True}) 
 397          self.__field_emailusedflags.writetobuffer(buf) 
 398          self.__field_urlslotsused.writetobuffer(buf) 
 399          try: self.__field_urlusedflags 
 400          except: 
 401              self.__field_urlusedflags=LIST(**{'elementclass': _gen_p_sanyo6600_103, 'length': MAXURLS, 'createdefault': True}) 
 402          self.__field_urlusedflags.writetobuffer(buf) 
 403          self.__field_num_address.writetobuffer(buf) 
 404          try: self.__field_addressusedflags 
 405          except: 
 406              self.__field_addressusedflags=LIST(**{'elementclass': _gen_p_sanyo6600_107, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 
 407          self.__field_addressusedflags.writetobuffer(buf) 
 408          self.__field_num_memo.writetobuffer(buf) 
 409          try: self.__field_memousedflags 
 410          except: 
 411              self.__field_memousedflags=LIST(**{'elementclass': _gen_p_sanyo6600_111, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 
 412          self.__field_memousedflags.writetobuffer(buf) 
 413          try: self.__field_junk 
 414          except: 
 415              self.__field_junk=UNKNOWN(**{'sizeinbytes': 391}) 
 416          self.__field_junk.writetobuffer(buf) 
 417          self._bufferendoffset=buf.getcurrentoffset() 
 418          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 419   
 420   
 421 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 422          'Reads this packet from the supplied buffer' 
 423          self._bufferstartoffset=buf.getcurrentoffset() 
 424          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 425          self.__field_groupslotsused=UINT(**{'sizeinbytes': 1}) 
 426          self.__field_groupslotsused.readfrombuffer(buf) 
 427          self.__field_pad=UNKNOWN(**{'sizeinbytes': 2}) 
 428          self.__field_pad.readfrombuffer(buf) 
 429          self.__field_groupslotusedflags=LIST(**{'elementclass': _gen_p_sanyo6600_79, 'length': NUMGROUPS, 'createdefault': True}) 
 430          self.__field_groupslotusedflags.readfrombuffer(buf) 
 431          self.__field_slotsused=UINT(**{'sizeinbytes': 2}) 
 432          self.__field_slotsused.readfrombuffer(buf) 
 433          self.__field_usedflags=LIST(**{'elementclass': _gen_p_sanyo6600_83, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 
 434          self.__field_usedflags.readfrombuffer(buf) 
 435          self.__field_speeddialindex=LIST(**{'elementclass': _gen_p_sanyo6600_85, 'length': _NUMSPEEDDIALS}) 
 436          self.__field_speeddialindex.readfrombuffer(buf) 
 437          self.__field_nameslotsused=UINT(**{'sizeinbytes': 2}) 
 438          self.__field_nameslotsused.readfrombuffer(buf) 
 439          self.__field_nameusedflags=LIST(**{'elementclass': _gen_p_sanyo6600_89, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 
 440          self.__field_nameusedflags.readfrombuffer(buf) 
 441          self.__field_sortorder=LIST(**{'elementclass': _gen_p_sanyo6600_91, 'length': NUMPHONEBOOKENTRIES}) 
 442          self.__field_sortorder.readfrombuffer(buf) 
 443          self.__field_pbfirstletters=USTRING(**{'terminator': None, 'sizeinbytes': NUMPHONEBOOKENTRIES}) 
 444          self.__field_pbfirstletters.readfrombuffer(buf) 
 445          self.__field_numslotsused=UINT(**{'sizeinbytes': 2}) 
 446          self.__field_numslotsused.readfrombuffer(buf) 
 447          self.__field_numusedflags=LIST(**{'elementclass': _gen_p_sanyo6600_96, 'length': MAXNUMBERS, 'createdefault': True}) 
 448          self.__field_numusedflags.readfrombuffer(buf) 
 449          self.__field_emailslotsused=UINT(**{'sizeinbytes': 2}) 
 450          self.__field_emailslotsused.readfrombuffer(buf) 
 451          self.__field_emailusedflags=LIST(**{'elementclass': _gen_p_sanyo6600_100, 'length': MAXEMAILS, 'createdefault': True}) 
 452          self.__field_emailusedflags.readfrombuffer(buf) 
 453          self.__field_urlslotsused=UINT(**{'sizeinbytes': 2}) 
 454          self.__field_urlslotsused.readfrombuffer(buf) 
 455          self.__field_urlusedflags=LIST(**{'elementclass': _gen_p_sanyo6600_103, 'length': MAXURLS, 'createdefault': True}) 
 456          self.__field_urlusedflags.readfrombuffer(buf) 
 457          self.__field_num_address=UINT(**{'sizeinbytes': 2}) 
 458          self.__field_num_address.readfrombuffer(buf) 
 459          self.__field_addressusedflags=LIST(**{'elementclass': _gen_p_sanyo6600_107, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 
 460          self.__field_addressusedflags.readfrombuffer(buf) 
 461          self.__field_num_memo=UINT(**{'sizeinbytes': 2}) 
 462          self.__field_num_memo.readfrombuffer(buf) 
 463          self.__field_memousedflags=LIST(**{'elementclass': _gen_p_sanyo6600_111, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 
 464          self.__field_memousedflags.readfrombuffer(buf) 
 465          self.__field_junk=UNKNOWN(**{'sizeinbytes': 391}) 
 466          self.__field_junk.readfrombuffer(buf) 
 467          self._bufferendoffset=buf.getcurrentoffset() 
 468   
 469   
 470 -    def __getfield_startcommand(self): 
 471          return self.__field_startcommand.getvalue() 
 472   
 473 -    def __setfield_startcommand(self, value): 
 474          if isinstance(value,UINT): 
 475              self.__field_startcommand=value 
 476          else: 
 477              self.__field_startcommand=UINT(value,**{'constant': 0x76}) 
 478   
 479 -    def __delfield_startcommand(self): del self.__field_startcommand 
 480   
 481      startcommand=property(__getfield_startcommand, __setfield_startcommand, __delfield_startcommand, "Starting command for R/W buf parts") 
 482   
 483 -    def __getfield_bufsize(self): 
 484          return self.__field_bufsize.getvalue() 
 485   
 486 -    def __setfield_bufsize(self, value): 
 487          if isinstance(value,UINT): 
 488              self.__field_bufsize=value 
 489          else: 
 490              self.__field_bufsize=UINT(value,**{'constant': 6144}) 
 491   
 492 -    def __delfield_bufsize(self): del self.__field_bufsize 
 493   
 494      bufsize=property(__getfield_bufsize, __setfield_bufsize, __delfield_bufsize, None) 
 495   
 496 -    def __getfield_comment(self): 
 497          try: self.__field_comment 
 498          except: 
 499              self.__field_comment=USTRING(**{'default': "sort buffer"}) 
 500          return self.__field_comment.getvalue() 
 501   
 502 -    def __setfield_comment(self, value): 
 503          if isinstance(value,USTRING): 
 504              self.__field_comment=value 
 505          else: 
 506              self.__field_comment=USTRING(value,**{'default': "sort buffer"}) 
 507   
 508 -    def __delfield_comment(self): del self.__field_comment 
 509   
 510      comment=property(__getfield_comment, __setfield_comment, __delfield_comment, None) 
 511   
 512 -    def __getfield_groupslotsused(self): 
 513          return self.__field_groupslotsused.getvalue() 
 514   
 515 -    def __setfield_groupslotsused(self, value): 
 516          if isinstance(value,UINT): 
 517              self.__field_groupslotsused=value 
 518          else: 
 519              self.__field_groupslotsused=UINT(value,**{'sizeinbytes': 1}) 
 520   
 521 -    def __delfield_groupslotsused(self): del self.__field_groupslotsused 
 522   
 523      groupslotsused=property(__getfield_groupslotsused, __setfield_groupslotsused, __delfield_groupslotsused, None) 
 524   
 525 -    def __getfield_pad(self): 
 526          try: self.__field_pad 
 527          except: 
 528              self.__field_pad=UNKNOWN(**{'sizeinbytes': 2}) 
 529          return self.__field_pad.getvalue() 
 530   
 531 -    def __setfield_pad(self, value): 
 532          if isinstance(value,UNKNOWN): 
 533              self.__field_pad=value 
 534          else: 
 535              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 2}) 
 536   
 537 -    def __delfield_pad(self): del self.__field_pad 
 538   
 539      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
 540   
 541 -    def __getfield_groupslotusedflags(self): 
 542          try: self.__field_groupslotusedflags 
 543          except: 
 544              self.__field_groupslotusedflags=LIST(**{'elementclass': _gen_p_sanyo6600_79, 'length': NUMGROUPS, 'createdefault': True}) 
 545          return self.__field_groupslotusedflags.getvalue() 
 546   
 547 -    def __setfield_groupslotusedflags(self, value): 
 548          if isinstance(value,LIST): 
 549              self.__field_groupslotusedflags=value 
 550          else: 
 551              self.__field_groupslotusedflags=LIST(value,**{'elementclass': _gen_p_sanyo6600_79, 'length': NUMGROUPS, 'createdefault': True}) 
 552   
 553 -    def __delfield_groupslotusedflags(self): del self.__field_groupslotusedflags 
 554   
 555      groupslotusedflags=property(__getfield_groupslotusedflags, __setfield_groupslotusedflags, __delfield_groupslotusedflags, None) 
 556   
 557 -    def __getfield_slotsused(self): 
 558          return self.__field_slotsused.getvalue() 
 559   
 560 -    def __setfield_slotsused(self, value): 
 561          if isinstance(value,UINT): 
 562              self.__field_slotsused=value 
 563          else: 
 564              self.__field_slotsused=UINT(value,**{'sizeinbytes': 2}) 
 565   
 566 -    def __delfield_slotsused(self): del self.__field_slotsused 
 567   
 568      slotsused=property(__getfield_slotsused, __setfield_slotsused, __delfield_slotsused, None) 
 569   
 570 -    def __getfield_usedflags(self): 
 571          try: self.__field_usedflags 
 572          except: 
 573              self.__field_usedflags=LIST(**{'elementclass': _gen_p_sanyo6600_83, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 
 574          return self.__field_usedflags.getvalue() 
 575   
 576 -    def __setfield_usedflags(self, value): 
 577          if isinstance(value,LIST): 
 578              self.__field_usedflags=value 
 579          else: 
 580              self.__field_usedflags=LIST(value,**{'elementclass': _gen_p_sanyo6600_83, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 
 581   
 582 -    def __delfield_usedflags(self): del self.__field_usedflags 
 583   
 584      usedflags=property(__getfield_usedflags, __setfield_usedflags, __delfield_usedflags, None) 
 585   
 586 -    def __getfield_speeddialindex(self): 
 587          try: self.__field_speeddialindex 
 588          except: 
 589              self.__field_speeddialindex=LIST(**{'elementclass': _gen_p_sanyo6600_85, 'length': _NUMSPEEDDIALS}) 
 590          return self.__field_speeddialindex.getvalue() 
 591   
 592 -    def __setfield_speeddialindex(self, value): 
 593          if isinstance(value,LIST): 
 594              self.__field_speeddialindex=value 
 595          else: 
 596              self.__field_speeddialindex=LIST(value,**{'elementclass': _gen_p_sanyo6600_85, 'length': _NUMSPEEDDIALS}) 
 597   
 598 -    def __delfield_speeddialindex(self): del self.__field_speeddialindex 
 599   
 600      speeddialindex=property(__getfield_speeddialindex, __setfield_speeddialindex, __delfield_speeddialindex, None) 
 601   
 602 -    def __getfield_nameslotsused(self): 
 603          return self.__field_nameslotsused.getvalue() 
 604   
 605 -    def __setfield_nameslotsused(self, value): 
 606          if isinstance(value,UINT): 
 607              self.__field_nameslotsused=value 
 608          else: 
 609              self.__field_nameslotsused=UINT(value,**{'sizeinbytes': 2}) 
 610   
 611 -    def __delfield_nameslotsused(self): del self.__field_nameslotsused 
 612   
 613      nameslotsused=property(__getfield_nameslotsused, __setfield_nameslotsused, __delfield_nameslotsused, "Always seems to be the same.  Why duplicated?") 
 614   
 615 -    def __getfield_nameusedflags(self): 
 616          try: self.__field_nameusedflags 
 617          except: 
 618              self.__field_nameusedflags=LIST(**{'elementclass': _gen_p_sanyo6600_89, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 
 619          return self.__field_nameusedflags.getvalue() 
 620   
 621 -    def __setfield_nameusedflags(self, value): 
 622          if isinstance(value,LIST): 
 623              self.__field_nameusedflags=value 
 624          else: 
 625              self.__field_nameusedflags=LIST(value,**{'elementclass': _gen_p_sanyo6600_89, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 
 626   
 627 -    def __delfield_nameusedflags(self): del self.__field_nameusedflags 
 628   
 629      nameusedflags=property(__getfield_nameusedflags, __setfield_nameusedflags, __delfield_nameusedflags, None) 
 630   
 631 -    def __getfield_sortorder(self): 
 632          try: self.__field_sortorder 
 633          except: 
 634              self.__field_sortorder=LIST(**{'elementclass': _gen_p_sanyo6600_91, 'length': NUMPHONEBOOKENTRIES}) 
 635          return self.__field_sortorder.getvalue() 
 636   
 637 -    def __setfield_sortorder(self, value): 
 638          if isinstance(value,LIST): 
 639              self.__field_sortorder=value 
 640          else: 
 641              self.__field_sortorder=LIST(value,**{'elementclass': _gen_p_sanyo6600_91, 'length': NUMPHONEBOOKENTRIES}) 
 642   
 643 -    def __delfield_sortorder(self): del self.__field_sortorder 
 644   
 645      sortorder=property(__getfield_sortorder, __setfield_sortorder, __delfield_sortorder, None) 
 646   
 647 -    def __getfield_pbfirstletters(self): 
 648          return self.__field_pbfirstletters.getvalue() 
 649   
 650 -    def __setfield_pbfirstletters(self, value): 
 651          if isinstance(value,USTRING): 
 652              self.__field_pbfirstletters=value 
 653          else: 
 654              self.__field_pbfirstletters=USTRING(value,**{'terminator': None, 'sizeinbytes': NUMPHONEBOOKENTRIES}) 
 655   
 656 -    def __delfield_pbfirstletters(self): del self.__field_pbfirstletters 
 657   
 658      pbfirstletters=property(__getfield_pbfirstletters, __setfield_pbfirstletters, __delfield_pbfirstletters, None) 
 659   
 660 -    def __getfield_numslotsused(self): 
 661          return self.__field_numslotsused.getvalue() 
 662   
 663 -    def __setfield_numslotsused(self, value): 
 664          if isinstance(value,UINT): 
 665              self.__field_numslotsused=value 
 666          else: 
 667              self.__field_numslotsused=UINT(value,**{'sizeinbytes': 2}) 
 668   
 669 -    def __delfield_numslotsused(self): del self.__field_numslotsused 
 670   
 671      numslotsused=property(__getfield_numslotsused, __setfield_numslotsused, __delfield_numslotsused, "Number of phone number slots used") 
 672   
 673 -    def __getfield_numusedflags(self): 
 674          try: self.__field_numusedflags 
 675          except: 
 676              self.__field_numusedflags=LIST(**{'elementclass': _gen_p_sanyo6600_96, 'length': MAXNUMBERS, 'createdefault': True}) 
 677          return self.__field_numusedflags.getvalue() 
 678   
 679 -    def __setfield_numusedflags(self, value): 
 680          if isinstance(value,LIST): 
 681              self.__field_numusedflags=value 
 682          else: 
 683              self.__field_numusedflags=LIST(value,**{'elementclass': _gen_p_sanyo6600_96, 'length': MAXNUMBERS, 'createdefault': True}) 
 684   
 685 -    def __delfield_numusedflags(self): del self.__field_numusedflags 
 686   
 687      numusedflags=property(__getfield_numusedflags, __setfield_numusedflags, __delfield_numusedflags, None) 
 688   
 689 -    def __getfield_emailslotsused(self): 
 690          return self.__field_emailslotsused.getvalue() 
 691   
 692 -    def __setfield_emailslotsused(self, value): 
 693          if isinstance(value,UINT): 
 694              self.__field_emailslotsused=value 
 695          else: 
 696              self.__field_emailslotsused=UINT(value,**{'sizeinbytes': 2}) 
 697   
 698 -    def __delfield_emailslotsused(self): del self.__field_emailslotsused 
 699   
 700      emailslotsused=property(__getfield_emailslotsused, __setfield_emailslotsused, __delfield_emailslotsused, None) 
 701   
 702 -    def __getfield_emailusedflags(self): 
 703          try: self.__field_emailusedflags 
 704          except: 
 705              self.__field_emailusedflags=LIST(**{'elementclass': _gen_p_sanyo6600_100, 'length': MAXEMAILS, 'createdefault': True}) 
 706          return self.__field_emailusedflags.getvalue() 
 707   
 708 -    def __setfield_emailusedflags(self, value): 
 709          if isinstance(value,LIST): 
 710              self.__field_emailusedflags=value 
 711          else: 
 712              self.__field_emailusedflags=LIST(value,**{'elementclass': _gen_p_sanyo6600_100, 'length': MAXEMAILS, 'createdefault': True}) 
 713   
 714 -    def __delfield_emailusedflags(self): del self.__field_emailusedflags 
 715   
 716      emailusedflags=property(__getfield_emailusedflags, __setfield_emailusedflags, __delfield_emailusedflags, None) 
 717   
 718 -    def __getfield_urlslotsused(self): 
 719          return self.__field_urlslotsused.getvalue() 
 720   
 721 -    def __setfield_urlslotsused(self, value): 
 722          if isinstance(value,UINT): 
 723              self.__field_urlslotsused=value 
 724          else: 
 725              self.__field_urlslotsused=UINT(value,**{'sizeinbytes': 2}) 
 726   
 727 -    def __delfield_urlslotsused(self): del self.__field_urlslotsused 
 728   
 729      urlslotsused=property(__getfield_urlslotsused, __setfield_urlslotsused, __delfield_urlslotsused, None) 
 730   
 731 -    def __getfield_urlusedflags(self): 
 732          try: self.__field_urlusedflags 
 733          except: 
 734              self.__field_urlusedflags=LIST(**{'elementclass': _gen_p_sanyo6600_103, 'length': MAXURLS, 'createdefault': True}) 
 735          return self.__field_urlusedflags.getvalue() 
 736   
 737 -    def __setfield_urlusedflags(self, value): 
 738          if isinstance(value,LIST): 
 739              self.__field_urlusedflags=value 
 740          else: 
 741              self.__field_urlusedflags=LIST(value,**{'elementclass': _gen_p_sanyo6600_103, 'length': MAXURLS, 'createdefault': True}) 
 742   
 743 -    def __delfield_urlusedflags(self): del self.__field_urlusedflags 
 744   
 745      urlusedflags=property(__getfield_urlusedflags, __setfield_urlusedflags, __delfield_urlusedflags, None) 
 746   
 747 -    def __getfield_num_address(self): 
 748          return self.__field_num_address.getvalue() 
 749   
 750 -    def __setfield_num_address(self, value): 
 751          if isinstance(value,UINT): 
 752              self.__field_num_address=value 
 753          else: 
 754              self.__field_num_address=UINT(value,**{'sizeinbytes': 2}) 
 755   
 756 -    def __delfield_num_address(self): del self.__field_num_address 
 757   
 758      num_address=property(__getfield_num_address, __setfield_num_address, __delfield_num_address, None) 
 759   
 760 -    def __getfield_addressusedflags(self): 
 761          try: self.__field_addressusedflags 
 762          except: 
 763              self.__field_addressusedflags=LIST(**{'elementclass': _gen_p_sanyo6600_107, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 
 764          return self.__field_addressusedflags.getvalue() 
 765   
 766 -    def __setfield_addressusedflags(self, value): 
 767          if isinstance(value,LIST): 
 768              self.__field_addressusedflags=value 
 769          else: 
 770              self.__field_addressusedflags=LIST(value,**{'elementclass': _gen_p_sanyo6600_107, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 
 771   
 772 -    def __delfield_addressusedflags(self): del self.__field_addressusedflags 
 773   
 774      addressusedflags=property(__getfield_addressusedflags, __setfield_addressusedflags, __delfield_addressusedflags, None) 
 775   
 776 -    def __getfield_num_memo(self): 
 777          return self.__field_num_memo.getvalue() 
 778   
 779 -    def __setfield_num_memo(self, value): 
 780          if isinstance(value,UINT): 
 781              self.__field_num_memo=value 
 782          else: 
 783              self.__field_num_memo=UINT(value,**{'sizeinbytes': 2}) 
 784   
 785 -    def __delfield_num_memo(self): del self.__field_num_memo 
 786   
 787      num_memo=property(__getfield_num_memo, __setfield_num_memo, __delfield_num_memo, None) 
 788   
 789 -    def __getfield_memousedflags(self): 
 790          try: self.__field_memousedflags 
 791          except: 
 792              self.__field_memousedflags=LIST(**{'elementclass': _gen_p_sanyo6600_111, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 
 793          return self.__field_memousedflags.getvalue() 
 794   
 795 -    def __setfield_memousedflags(self, value): 
 796          if isinstance(value,LIST): 
 797              self.__field_memousedflags=value 
 798          else: 
 799              self.__field_memousedflags=LIST(value,**{'elementclass': _gen_p_sanyo6600_111, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 
 800   
 801 -    def __delfield_memousedflags(self): del self.__field_memousedflags 
 802   
 803      memousedflags=property(__getfield_memousedflags, __setfield_memousedflags, __delfield_memousedflags, None) 
 804   
 805 -    def __getfield_junk(self): 
 806          try: self.__field_junk 
 807          except: 
 808              self.__field_junk=UNKNOWN(**{'sizeinbytes': 391}) 
 809          return self.__field_junk.getvalue() 
 810   
 811 -    def __setfield_junk(self, value): 
 812          if isinstance(value,UNKNOWN): 
 813              self.__field_junk=value 
 814          else: 
 815              self.__field_junk=UNKNOWN(value,**{'sizeinbytes': 391}) 
 816   
 817 -    def __delfield_junk(self): del self.__field_junk 
 818   
 819      junk=property(__getfield_junk, __setfield_junk, __delfield_junk, None) 
 820   
 821 -    def iscontainer(self): 
 822          return True 
 823   
 824 -    def containerelements(self): 
 825          yield ('startcommand', self.__field_startcommand, "Starting command for R/W buf parts") 
 826          yield ('bufsize', self.__field_bufsize, None) 
 827          yield ('comment', self.__field_comment, None) 
 828          yield ('groupslotsused', self.__field_groupslotsused, None) 
 829          yield ('pad', self.__field_pad, None) 
 830          yield ('groupslotusedflags', self.__field_groupslotusedflags, None) 
 831          yield ('slotsused', self.__field_slotsused, None) 
 832          yield ('usedflags', self.__field_usedflags, None) 
 833          yield ('speeddialindex', self.__field_speeddialindex, None) 
 834          yield ('nameslotsused', self.__field_nameslotsused, "Always seems to be the same.  Why duplicated?") 
 835          yield ('nameusedflags', self.__field_nameusedflags, None) 
 836          yield ('sortorder', self.__field_sortorder, None) 
 837          yield ('pbfirstletters', self.__field_pbfirstletters, None) 
 838          yield ('numslotsused', self.__field_numslotsused, "Number of phone number slots used") 
 839          yield ('numusedflags', self.__field_numusedflags, None) 
 840          yield ('emailslotsused', self.__field_emailslotsused, None) 
 841          yield ('emailusedflags', self.__field_emailusedflags, None) 
 842          yield ('urlslotsused', self.__field_urlslotsused, None) 
 843          yield ('urlusedflags', self.__field_urlusedflags, None) 
 844          yield ('num_address', self.__field_num_address, None) 
 845          yield ('addressusedflags', self.__field_addressusedflags, None) 
 846          yield ('num_memo', self.__field_num_memo, None) 
 847          yield ('memousedflags', self.__field_memousedflags, None) 
 848          yield ('junk', self.__field_junk, None) 
 849   
 850   
 851   
 852   
 853 -class _gen_p_sanyo6600_79(BaseProtogenClass): 
 854      'Anonymous inner class' 
 855      __fields=['used'] 
 856   
 857 -    def __init__(self, *args, **kwargs): 
 858          dict={} 
 859          # What was supplied to this function 
 860          dict.update(kwargs) 
 861          # Parent constructor 
 862          super(_gen_p_sanyo6600_79,self).__init__(**dict) 
 863          if self.__class__ is _gen_p_sanyo6600_79: 
 864              self._update(args,dict) 
 865   
 866   
 867 -    def getfields(self): 
 868          return self.__fields 
 869   
 870   
 871 -    def _update(self, args, kwargs): 
 872          super(_gen_p_sanyo6600_79,self)._update(args,kwargs) 
 873          keys=kwargs.keys() 
 874          for key in keys: 
 875              if key in self.__fields: 
 876                  setattr(self, key, kwargs[key]) 
 877                  del kwargs[key] 
 878          # Were any unrecognized kwargs passed in? 
 879          if __debug__: 
 880              self._complainaboutunusedargs(_gen_p_sanyo6600_79,kwargs) 
 881          if len(args): 
 882              dict2={'sizeinbytes': 1} 
 883              dict2.update(kwargs) 
 884              kwargs=dict2 
 885              self.__field_used=UINT(*args,**dict2) 
 886          # Make all P fields that haven't already been constructed 
 887   
 888   
 889 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 890          'Writes this packet to the supplied buffer' 
 891          self._bufferstartoffset=buf.getcurrentoffset() 
 892          self.__field_used.writetobuffer(buf) 
 893          self._bufferendoffset=buf.getcurrentoffset() 
 894          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 895   
 896   
 897 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 898          'Reads this packet from the supplied buffer' 
 899          self._bufferstartoffset=buf.getcurrentoffset() 
 900          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 901          self.__field_used=UINT(**{'sizeinbytes': 1}) 
 902          self.__field_used.readfrombuffer(buf) 
 903          self._bufferendoffset=buf.getcurrentoffset() 
 904   
 905   
 906 -    def __getfield_used(self): 
 907          return self.__field_used.getvalue() 
 908   
 909 -    def __setfield_used(self, value): 
 910          if isinstance(value,UINT): 
 911              self.__field_used=value 
 912          else: 
 913              self.__field_used=UINT(value,**{'sizeinbytes': 1}) 
 914   
 915 -    def __delfield_used(self): del self.__field_used 
 916   
 917      used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 
 918   
 919 -    def iscontainer(self): 
 920          return True 
 921   
 922 -    def containerelements(self): 
 923          yield ('used', self.__field_used, "1 if slot in use") 
 924   
 925   
 926   
 927   
 928 -class _gen_p_sanyo6600_83(BaseProtogenClass): 
 929      'Anonymous inner class' 
 930      __fields=['used'] 
 931   
 932 -    def __init__(self, *args, **kwargs): 
 933          dict={} 
 934          # What was supplied to this function 
 935          dict.update(kwargs) 
 936          # Parent constructor 
 937          super(_gen_p_sanyo6600_83,self).__init__(**dict) 
 938          if self.__class__ is _gen_p_sanyo6600_83: 
 939              self._update(args,dict) 
 940   
 941   
 942 -    def getfields(self): 
 943          return self.__fields 
 944   
 945   
 946 -    def _update(self, args, kwargs): 
 947          super(_gen_p_sanyo6600_83,self)._update(args,kwargs) 
 948          keys=kwargs.keys() 
 949          for key in keys: 
 950              if key in self.__fields: 
 951                  setattr(self, key, kwargs[key]) 
 952                  del kwargs[key] 
 953          # Were any unrecognized kwargs passed in? 
 954          if __debug__: 
 955              self._complainaboutunusedargs(_gen_p_sanyo6600_83,kwargs) 
 956          if len(args): 
 957              dict2={'sizeinbytes': 1} 
 958              dict2.update(kwargs) 
 959              kwargs=dict2 
 960              self.__field_used=UINT(*args,**dict2) 
 961          # Make all P fields that haven't already been constructed 
 962   
 963   
 964 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 965          'Writes this packet to the supplied buffer' 
 966          self._bufferstartoffset=buf.getcurrentoffset() 
 967          self.__field_used.writetobuffer(buf) 
 968          self._bufferendoffset=buf.getcurrentoffset() 
 969          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 970   
 971   
 972 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 973          'Reads this packet from the supplied buffer' 
 974          self._bufferstartoffset=buf.getcurrentoffset() 
 975          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 976          self.__field_used=UINT(**{'sizeinbytes': 1}) 
 977          self.__field_used.readfrombuffer(buf) 
 978          self._bufferendoffset=buf.getcurrentoffset() 
 979   
 980   
 981 -    def __getfield_used(self): 
 982          return self.__field_used.getvalue() 
 983   
 984 -    def __setfield_used(self, value): 
 985          if isinstance(value,UINT): 
 986              self.__field_used=value 
 987          else: 
 988              self.__field_used=UINT(value,**{'sizeinbytes': 1}) 
 989   
 990 -    def __delfield_used(self): del self.__field_used 
 991   
 992      used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 
 993   
 994 -    def iscontainer(self): 
 995          return True 
 996   
 997 -    def containerelements(self): 
 998          yield ('used', self.__field_used, "1 if slot in use") 
 999   
1000   
1001   
1002   
1003 -class _gen_p_sanyo6600_85(BaseProtogenClass): 
1004      'Anonymous inner class' 
1005      __fields=['numslot'] 
1006   
1007 -    def __init__(self, *args, **kwargs): 
1008          dict={} 
1009          # What was supplied to this function 
1010          dict.update(kwargs) 
1011          # Parent constructor 
1012          super(_gen_p_sanyo6600_85,self).__init__(**dict) 
1013          if self.__class__ is _gen_p_sanyo6600_85: 
1014              self._update(args,dict) 
1015   
1016   
1017 -    def getfields(self): 
1018          return self.__fields 
1019   
1020   
1021 -    def _update(self, args, kwargs): 
1022          super(_gen_p_sanyo6600_85,self)._update(args,kwargs) 
1023          keys=kwargs.keys() 
1024          for key in keys: 
1025              if key in self.__fields: 
1026                  setattr(self, key, kwargs[key]) 
1027                  del kwargs[key] 
1028          # Were any unrecognized kwargs passed in? 
1029          if __debug__: 
1030              self._complainaboutunusedargs(_gen_p_sanyo6600_85,kwargs) 
1031          if len(args): 
1032              dict2={'sizeinbytes': 2, 'default': 0xffff} 
1033              dict2.update(kwargs) 
1034              kwargs=dict2 
1035              self.__field_numslot=UINT(*args,**dict2) 
1036          # Make all P fields that haven't already been constructed 
1037   
1038   
1039 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1040          'Writes this packet to the supplied buffer' 
1041          self._bufferstartoffset=buf.getcurrentoffset() 
1042          self.__field_numslot.writetobuffer(buf) 
1043          self._bufferendoffset=buf.getcurrentoffset() 
1044          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1045   
1046   
1047 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1048          'Reads this packet from the supplied buffer' 
1049          self._bufferstartoffset=buf.getcurrentoffset() 
1050          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1051          self.__field_numslot=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
1052          self.__field_numslot.readfrombuffer(buf) 
1053          self._bufferendoffset=buf.getcurrentoffset() 
1054   
1055   
1056 -    def __getfield_numslot(self): 
1057          return self.__field_numslot.getvalue() 
1058   
1059 -    def __setfield_numslot(self, value): 
1060          if isinstance(value,UINT): 
1061              self.__field_numslot=value 
1062          else: 
1063              self.__field_numslot=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff}) 
1064   
1065 -    def __delfield_numslot(self): del self.__field_numslot 
1066   
1067      numslot=property(__getfield_numslot, __setfield_numslot, __delfield_numslot, None) 
1068   
1069 -    def iscontainer(self): 
1070          return True 
1071   
1072 -    def containerelements(self): 
1073          yield ('numslot', self.__field_numslot, None) 
1074   
1075   
1076   
1077   
1078 -class _gen_p_sanyo6600_89(BaseProtogenClass): 
1079      'Anonymous inner class' 
1080      __fields=['used'] 
1081   
1082 -    def __init__(self, *args, **kwargs): 
1083          dict={} 
1084          # What was supplied to this function 
1085          dict.update(kwargs) 
1086          # Parent constructor 
1087          super(_gen_p_sanyo6600_89,self).__init__(**dict) 
1088          if self.__class__ is _gen_p_sanyo6600_89: 
1089              self._update(args,dict) 
1090   
1091   
1092 -    def getfields(self): 
1093          return self.__fields 
1094   
1095   
1096 -    def _update(self, args, kwargs): 
1097          super(_gen_p_sanyo6600_89,self)._update(args,kwargs) 
1098          keys=kwargs.keys() 
1099          for key in keys: 
1100              if key in self.__fields: 
1101                  setattr(self, key, kwargs[key]) 
1102                  del kwargs[key] 
1103          # Were any unrecognized kwargs passed in? 
1104          if __debug__: 
1105              self._complainaboutunusedargs(_gen_p_sanyo6600_89,kwargs) 
1106          if len(args): 
1107              dict2={'sizeinbytes': 1} 
1108              dict2.update(kwargs) 
1109              kwargs=dict2 
1110              self.__field_used=UINT(*args,**dict2) 
1111          # Make all P fields that haven't already been constructed 
1112   
1113   
1114 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1115          'Writes this packet to the supplied buffer' 
1116          self._bufferstartoffset=buf.getcurrentoffset() 
1117          self.__field_used.writetobuffer(buf) 
1118          self._bufferendoffset=buf.getcurrentoffset() 
1119          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1120   
1121   
1122 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1123          'Reads this packet from the supplied buffer' 
1124          self._bufferstartoffset=buf.getcurrentoffset() 
1125          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1126          self.__field_used=UINT(**{'sizeinbytes': 1}) 
1127          self.__field_used.readfrombuffer(buf) 
1128          self._bufferendoffset=buf.getcurrentoffset() 
1129   
1130   
1131 -    def __getfield_used(self): 
1132          return self.__field_used.getvalue() 
1133   
1134 -    def __setfield_used(self, value): 
1135          if isinstance(value,UINT): 
1136              self.__field_used=value 
1137          else: 
1138              self.__field_used=UINT(value,**{'sizeinbytes': 1}) 
1139   
1140 -    def __delfield_used(self): del self.__field_used 
1141   
1142      used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 
1143   
1144 -    def iscontainer(self): 
1145          return True 
1146   
1147 -    def containerelements(self): 
1148          yield ('used', self.__field_used, "1 if slot in use") 
1149   
1150   
1151   
1152   
1153 -class _gen_p_sanyo6600_91(BaseProtogenClass): 
1154      'Anonymous inner class' 
1155      __fields=['pbslot'] 
1156   
1157 -    def __init__(self, *args, **kwargs): 
1158          dict={} 
1159          # What was supplied to this function 
1160          dict.update(kwargs) 
1161          # Parent constructor 
1162          super(_gen_p_sanyo6600_91,self).__init__(**dict) 
1163          if self.__class__ is _gen_p_sanyo6600_91: 
1164              self._update(args,dict) 
1165   
1166   
1167 -    def getfields(self): 
1168          return self.__fields 
1169   
1170   
1171 -    def _update(self, args, kwargs): 
1172          super(_gen_p_sanyo6600_91,self)._update(args,kwargs) 
1173          keys=kwargs.keys() 
1174          for key in keys: 
1175              if key in self.__fields: 
1176                  setattr(self, key, kwargs[key]) 
1177                  del kwargs[key] 
1178          # Were any unrecognized kwargs passed in? 
1179          if __debug__: 
1180              self._complainaboutunusedargs(_gen_p_sanyo6600_91,kwargs) 
1181          if len(args): 
1182              dict2={'sizeinbytes': 2, 'default': 0xffff} 
1183              dict2.update(kwargs) 
1184              kwargs=dict2 
1185              self.__field_pbslot=UINT(*args,**dict2) 
1186          # Make all P fields that haven't already been constructed 
1187   
1188   
1189 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1190          'Writes this packet to the supplied buffer' 
1191          self._bufferstartoffset=buf.getcurrentoffset() 
1192          self.__field_pbslot.writetobuffer(buf) 
1193          self._bufferendoffset=buf.getcurrentoffset() 
1194          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1195   
1196   
1197 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1198          'Reads this packet from the supplied buffer' 
1199          self._bufferstartoffset=buf.getcurrentoffset() 
1200          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1201          self.__field_pbslot=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
1202          self.__field_pbslot.readfrombuffer(buf) 
1203          self._bufferendoffset=buf.getcurrentoffset() 
1204   
1205   
1206 -    def __getfield_pbslot(self): 
1207          return self.__field_pbslot.getvalue() 
1208   
1209 -    def __setfield_pbslot(self, value): 
1210          if isinstance(value,UINT): 
1211              self.__field_pbslot=value 
1212          else: 
1213              self.__field_pbslot=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff}) 
1214   
1215 -    def __delfield_pbslot(self): del self.__field_pbslot 
1216   
1217      pbslot=property(__getfield_pbslot, __setfield_pbslot, __delfield_pbslot, None) 
1218   
1219 -    def iscontainer(self): 
1220          return True 
1221   
1222 -    def containerelements(self): 
1223          yield ('pbslot', self.__field_pbslot, None) 
1224   
1225   
1226   
1227   
1228 -class _gen_p_sanyo6600_96(BaseProtogenClass): 
1229      'Anonymous inner class' 
1230      __fields=['used'] 
1231   
1232 -    def __init__(self, *args, **kwargs): 
1233          dict={} 
1234          # What was supplied to this function 
1235          dict.update(kwargs) 
1236          # Parent constructor 
1237          super(_gen_p_sanyo6600_96,self).__init__(**dict) 
1238          if self.__class__ is _gen_p_sanyo6600_96: 
1239              self._update(args,dict) 
1240   
1241   
1242 -    def getfields(self): 
1243          return self.__fields 
1244   
1245   
1246 -    def _update(self, args, kwargs): 
1247          super(_gen_p_sanyo6600_96,self)._update(args,kwargs) 
1248          keys=kwargs.keys() 
1249          for key in keys: 
1250              if key in self.__fields: 
1251                  setattr(self, key, kwargs[key]) 
1252                  del kwargs[key] 
1253          # Were any unrecognized kwargs passed in? 
1254          if __debug__: 
1255              self._complainaboutunusedargs(_gen_p_sanyo6600_96,kwargs) 
1256          if len(args): 
1257              dict2={'sizeinbytes': 1} 
1258              dict2.update(kwargs) 
1259              kwargs=dict2 
1260              self.__field_used=UINT(*args,**dict2) 
1261          # Make all P fields that haven't already been constructed 
1262   
1263   
1264 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1265          'Writes this packet to the supplied buffer' 
1266          self._bufferstartoffset=buf.getcurrentoffset() 
1267          self.__field_used.writetobuffer(buf) 
1268          self._bufferendoffset=buf.getcurrentoffset() 
1269          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1270   
1271   
1272 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1273          'Reads this packet from the supplied buffer' 
1274          self._bufferstartoffset=buf.getcurrentoffset() 
1275          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1276          self.__field_used=UINT(**{'sizeinbytes': 1}) 
1277          self.__field_used.readfrombuffer(buf) 
1278          self._bufferendoffset=buf.getcurrentoffset() 
1279   
1280   
1281 -    def __getfield_used(self): 
1282          return self.__field_used.getvalue() 
1283   
1284 -    def __setfield_used(self, value): 
1285          if isinstance(value,UINT): 
1286              self.__field_used=value 
1287          else: 
1288              self.__field_used=UINT(value,**{'sizeinbytes': 1}) 
1289   
1290 -    def __delfield_used(self): del self.__field_used 
1291   
1292      used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 
1293   
1294 -    def iscontainer(self): 
1295          return True 
1296   
1297 -    def containerelements(self): 
1298          yield ('used', self.__field_used, "1 if slot in use") 
1299   
1300   
1301   
1302   
1303 -class _gen_p_sanyo6600_100(BaseProtogenClass): 
1304      'Anonymous inner class' 
1305      __fields=['used'] 
1306   
1307 -    def __init__(self, *args, **kwargs): 
1308          dict={} 
1309          # What was supplied to this function 
1310          dict.update(kwargs) 
1311          # Parent constructor 
1312          super(_gen_p_sanyo6600_100,self).__init__(**dict) 
1313          if self.__class__ is _gen_p_sanyo6600_100: 
1314              self._update(args,dict) 
1315   
1316   
1317 -    def getfields(self): 
1318          return self.__fields 
1319   
1320   
1321 -    def _update(self, args, kwargs): 
1322          super(_gen_p_sanyo6600_100,self)._update(args,kwargs) 
1323          keys=kwargs.keys() 
1324          for key in keys: 
1325              if key in self.__fields: 
1326                  setattr(self, key, kwargs[key]) 
1327                  del kwargs[key] 
1328          # Were any unrecognized kwargs passed in? 
1329          if __debug__: 
1330              self._complainaboutunusedargs(_gen_p_sanyo6600_100,kwargs) 
1331          if len(args): 
1332              dict2={'sizeinbytes': 1} 
1333              dict2.update(kwargs) 
1334              kwargs=dict2 
1335              self.__field_used=UINT(*args,**dict2) 
1336          # Make all P fields that haven't already been constructed 
1337   
1338   
1339 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1340          'Writes this packet to the supplied buffer' 
1341          self._bufferstartoffset=buf.getcurrentoffset() 
1342          self.__field_used.writetobuffer(buf) 
1343          self._bufferendoffset=buf.getcurrentoffset() 
1344          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1345   
1346   
1347 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1348          'Reads this packet from the supplied buffer' 
1349          self._bufferstartoffset=buf.getcurrentoffset() 
1350          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1351          self.__field_used=UINT(**{'sizeinbytes': 1}) 
1352          self.__field_used.readfrombuffer(buf) 
1353          self._bufferendoffset=buf.getcurrentoffset() 
1354   
1355   
1356 -    def __getfield_used(self): 
1357          return self.__field_used.getvalue() 
1358   
1359 -    def __setfield_used(self, value): 
1360          if isinstance(value,UINT): 
1361              self.__field_used=value 
1362          else: 
1363              self.__field_used=UINT(value,**{'sizeinbytes': 1}) 
1364   
1365 -    def __delfield_used(self): del self.__field_used 
1366   
1367      used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 
1368   
1369 -    def iscontainer(self): 
1370          return True 
1371   
1372 -    def containerelements(self): 
1373          yield ('used', self.__field_used, "1 if slot in use") 
1374   
1375   
1376   
1377   
1378 -class _gen_p_sanyo6600_103(BaseProtogenClass): 
1379      'Anonymous inner class' 
1380      __fields=['used'] 
1381   
1382 -    def __init__(self, *args, **kwargs): 
1383          dict={} 
1384          # What was supplied to this function 
1385          dict.update(kwargs) 
1386          # Parent constructor 
1387          super(_gen_p_sanyo6600_103,self).__init__(**dict) 
1388          if self.__class__ is _gen_p_sanyo6600_103: 
1389              self._update(args,dict) 
1390   
1391   
1392 -    def getfields(self): 
1393          return self.__fields 
1394   
1395   
1396 -    def _update(self, args, kwargs): 
1397          super(_gen_p_sanyo6600_103,self)._update(args,kwargs) 
1398          keys=kwargs.keys() 
1399          for key in keys: 
1400              if key in self.__fields: 
1401                  setattr(self, key, kwargs[key]) 
1402                  del kwargs[key] 
1403          # Were any unrecognized kwargs passed in? 
1404          if __debug__: 
1405              self._complainaboutunusedargs(_gen_p_sanyo6600_103,kwargs) 
1406          if len(args): 
1407              dict2={'sizeinbytes': 1} 
1408              dict2.update(kwargs) 
1409              kwargs=dict2 
1410              self.__field_used=UINT(*args,**dict2) 
1411          # Make all P fields that haven't already been constructed 
1412   
1413   
1414 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1415          'Writes this packet to the supplied buffer' 
1416          self._bufferstartoffset=buf.getcurrentoffset() 
1417          self.__field_used.writetobuffer(buf) 
1418          self._bufferendoffset=buf.getcurrentoffset() 
1419          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1420   
1421   
1422 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1423          'Reads this packet from the supplied buffer' 
1424          self._bufferstartoffset=buf.getcurrentoffset() 
1425          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1426          self.__field_used=UINT(**{'sizeinbytes': 1}) 
1427          self.__field_used.readfrombuffer(buf) 
1428          self._bufferendoffset=buf.getcurrentoffset() 
1429   
1430   
1431 -    def __getfield_used(self): 
1432          return self.__field_used.getvalue() 
1433   
1434 -    def __setfield_used(self, value): 
1435          if isinstance(value,UINT): 
1436              self.__field_used=value 
1437          else: 
1438              self.__field_used=UINT(value,**{'sizeinbytes': 1}) 
1439   
1440 -    def __delfield_used(self): del self.__field_used 
1441   
1442      used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 
1443   
1444 -    def iscontainer(self): 
1445          return True 
1446   
1447 -    def containerelements(self): 
1448          yield ('used', self.__field_used, "1 if slot in use") 
1449   
1450   
1451   
1452   
1453 -class _gen_p_sanyo6600_107(BaseProtogenClass): 
1454      'Anonymous inner class' 
1455      __fields=['used'] 
1456   
1457 -    def __init__(self, *args, **kwargs): 
1458          dict={} 
1459          # What was supplied to this function 
1460          dict.update(kwargs) 
1461          # Parent constructor 
1462          super(_gen_p_sanyo6600_107,self).__init__(**dict) 
1463          if self.__class__ is _gen_p_sanyo6600_107: 
1464              self._update(args,dict) 
1465   
1466   
1467 -    def getfields(self): 
1468          return self.__fields 
1469   
1470   
1471 -    def _update(self, args, kwargs): 
1472          super(_gen_p_sanyo6600_107,self)._update(args,kwargs) 
1473          keys=kwargs.keys() 
1474          for key in keys: 
1475              if key in self.__fields: 
1476                  setattr(self, key, kwargs[key]) 
1477                  del kwargs[key] 
1478          # Were any unrecognized kwargs passed in? 
1479          if __debug__: 
1480              self._complainaboutunusedargs(_gen_p_sanyo6600_107,kwargs) 
1481          if len(args): 
1482              dict2={'sizeinbytes': 1} 
1483              dict2.update(kwargs) 
1484              kwargs=dict2 
1485              self.__field_used=UINT(*args,**dict2) 
1486          # Make all P fields that haven't already been constructed 
1487   
1488   
1489 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1490          'Writes this packet to the supplied buffer' 
1491          self._bufferstartoffset=buf.getcurrentoffset() 
1492          self.__field_used.writetobuffer(buf) 
1493          self._bufferendoffset=buf.getcurrentoffset() 
1494          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1495   
1496   
1497 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1498          'Reads this packet from the supplied buffer' 
1499          self._bufferstartoffset=buf.getcurrentoffset() 
1500          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1501          self.__field_used=UINT(**{'sizeinbytes': 1}) 
1502          self.__field_used.readfrombuffer(buf) 
1503          self._bufferendoffset=buf.getcurrentoffset() 
1504   
1505   
1506 -    def __getfield_used(self): 
1507          return self.__field_used.getvalue() 
1508   
1509 -    def __setfield_used(self, value): 
1510          if isinstance(value,UINT): 
1511              self.__field_used=value 
1512          else: 
1513              self.__field_used=UINT(value,**{'sizeinbytes': 1}) 
1514   
1515 -    def __delfield_used(self): del self.__field_used 
1516   
1517      used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 
1518   
1519 -    def iscontainer(self): 
1520          return True 
1521   
1522 -    def containerelements(self): 
1523          yield ('used', self.__field_used, "1 if slot in use") 
1524   
1525   
1526   
1527   
1528 -class _gen_p_sanyo6600_111(BaseProtogenClass): 
1529      'Anonymous inner class' 
1530      __fields=['used'] 
1531   
1532 -    def __init__(self, *args, **kwargs): 
1533          dict={} 
1534          # What was supplied to this function 
1535          dict.update(kwargs) 
1536          # Parent constructor 
1537          super(_gen_p_sanyo6600_111,self).__init__(**dict) 
1538          if self.__class__ is _gen_p_sanyo6600_111: 
1539              self._update(args,dict) 
1540   
1541   
1542 -    def getfields(self): 
1543          return self.__fields 
1544   
1545   
1546 -    def _update(self, args, kwargs): 
1547          super(_gen_p_sanyo6600_111,self)._update(args,kwargs) 
1548          keys=kwargs.keys() 
1549          for key in keys: 
1550              if key in self.__fields: 
1551                  setattr(self, key, kwargs[key]) 
1552                  del kwargs[key] 
1553          # Were any unrecognized kwargs passed in? 
1554          if __debug__: 
1555              self._complainaboutunusedargs(_gen_p_sanyo6600_111,kwargs) 
1556          if len(args): 
1557              dict2={'sizeinbytes': 1} 
1558              dict2.update(kwargs) 
1559              kwargs=dict2 
1560              self.__field_used=UINT(*args,**dict2) 
1561          # Make all P fields that haven't already been constructed 
1562   
1563   
1564 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1565          'Writes this packet to the supplied buffer' 
1566          self._bufferstartoffset=buf.getcurrentoffset() 
1567          self.__field_used.writetobuffer(buf) 
1568          self._bufferendoffset=buf.getcurrentoffset() 
1569          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1570   
1571   
1572 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1573          'Reads this packet from the supplied buffer' 
1574          self._bufferstartoffset=buf.getcurrentoffset() 
1575          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1576          self.__field_used=UINT(**{'sizeinbytes': 1}) 
1577          self.__field_used.readfrombuffer(buf) 
1578          self._bufferendoffset=buf.getcurrentoffset() 
1579   
1580   
1581 -    def __getfield_used(self): 
1582          return self.__field_used.getvalue() 
1583   
1584 -    def __setfield_used(self, value): 
1585          if isinstance(value,UINT): 
1586              self.__field_used=value 
1587          else: 
1588              self.__field_used=UINT(value,**{'sizeinbytes': 1}) 
1589   
1590 -    def __delfield_used(self): del self.__field_used 
1591   
1592      used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 
1593   
1594 -    def iscontainer(self): 
1595          return True 
1596   
1597 -    def containerelements(self): 
1598          yield ('used', self.__field_used, "1 if slot in use") 
1599   
1600   
1601   
1602   
1603 -class cannedmessagerequest(BaseProtogenClass): 
1604      __fields=['header'] 
1605   
1606 -    def __init__(self, *args, **kwargs): 
1607          dict={} 
1608          # What was supplied to this function 
1609          dict.update(kwargs) 
1610          # Parent constructor 
1611          super(cannedmessagerequest,self).__init__(**dict) 
1612          if self.__class__ is cannedmessagerequest: 
1613              self._update(args,dict) 
1614   
1615   
1616 -    def getfields(self): 
1617          return self.__fields 
1618   
1619   
1620 -    def _update(self, args, kwargs): 
1621          super(cannedmessagerequest,self)._update(args,kwargs) 
1622          keys=kwargs.keys() 
1623          for key in keys: 
1624              if key in self.__fields: 
1625                  setattr(self, key, kwargs[key]) 
1626                  del kwargs[key] 
1627          # Were any unrecognized kwargs passed in? 
1628          if __debug__: 
1629              self._complainaboutunusedargs(cannedmessagerequest,kwargs) 
1630          if len(args): 
1631              dict2={'packettype': 0x0e,                   'command': 0x5b} 
1632              dict2.update(kwargs) 
1633              kwargs=dict2 
1634              self.__field_header=sanyoheader(*args,**dict2) 
1635          # Make all P fields that haven't already been constructed 
1636   
1637   
1638 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1639          'Writes this packet to the supplied buffer' 
1640          self._bufferstartoffset=buf.getcurrentoffset() 
1641          try: self.__field_header 
1642          except: 
1643              self.__field_header=sanyoheader(**{'packettype': 0x0e,                   'command': 0x5b}) 
1644          self.__field_header.writetobuffer(buf) 
1645          self._bufferendoffset=buf.getcurrentoffset() 
1646          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1647   
1648   
1649 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1650          'Reads this packet from the supplied buffer' 
1651          self._bufferstartoffset=buf.getcurrentoffset() 
1652          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1653          self.__field_header=sanyoheader(**{'packettype': 0x0e,                   'command': 0x5b}) 
1654          self.__field_header.readfrombuffer(buf) 
1655          self._bufferendoffset=buf.getcurrentoffset() 
1656   
1657   
1658 -    def __getfield_header(self): 
1659          try: self.__field_header 
1660          except: 
1661              self.__field_header=sanyoheader(**{'packettype': 0x0e,                   'command': 0x5b}) 
1662          return self.__field_header.getvalue() 
1663   
1664 -    def __setfield_header(self, value): 
1665          if isinstance(value,sanyoheader): 
1666              self.__field_header=value 
1667          else: 
1668              self.__field_header=sanyoheader(value,**{'packettype': 0x0e,                   'command': 0x5b}) 
1669   
1670 -    def __delfield_header(self): del self.__field_header 
1671   
1672      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
1673   
1674 -    def iscontainer(self): 
1675          return True 
1676   
1677 -    def containerelements(self): 
1678          yield ('header', self.__field_header, None) 
1679   
1680   
1681   
1682   
1683 -class pbinfo(BaseProtogenClass): 
1684      __fields=['fa', 'faset', 'byte1', 'byte2', 'byte3'] 
1685   
1686 -    def __init__(self, *args, **kwargs): 
1687          dict={} 
1688          # What was supplied to this function 
1689          dict.update(kwargs) 
1690          # Parent constructor 
1691          super(pbinfo,self).__init__(**dict) 
1692          if self.__class__ is pbinfo: 
1693              self._update(args,dict) 
1694   
1695   
1696 -    def getfields(self): 
1697          return self.__fields 
1698   
1699   
1700 -    def _update(self, args, kwargs): 
1701          super(pbinfo,self)._update(args,kwargs) 
1702          keys=kwargs.keys() 
1703          for key in keys: 
1704              if key in self.__fields: 
1705                  setattr(self, key, kwargs[key]) 
1706                  del kwargs[key] 
1707          # Were any unrecognized kwargs passed in? 
1708          if __debug__: 
1709              self._complainaboutunusedargs(pbinfo,kwargs) 
1710          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1711          # Make all P fields that haven't already been constructed 
1712   
1713   
1714 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1715          'Writes this packet to the supplied buffer' 
1716          self._bufferstartoffset=buf.getcurrentoffset() 
1717          try: self.__field_fa 
1718          except: 
1719              self.__field_fa=UINT(**{'sizeinbytes': 2, 'constant': 0x00fa}) 
1720          self.__field_fa.writetobuffer(buf) 
1721          try: self.__field_faset 
1722          except: 
1723              self.__field_faset=UINT(**{'sizeinbytes': 1, 'default': 0x02}) 
1724          self.__field_faset.writetobuffer(buf) 
1725          self.__field_byte1.writetobuffer(buf) 
1726          self.__field_byte2.writetobuffer(buf) 
1727          self.__field_byte3.writetobuffer(buf) 
1728          self._bufferendoffset=buf.getcurrentoffset() 
1729          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1730   
1731   
1732 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1733          'Reads this packet from the supplied buffer' 
1734          self._bufferstartoffset=buf.getcurrentoffset() 
1735          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1736          self.__field_fa=UINT(**{'sizeinbytes': 2, 'constant': 0x00fa}) 
1737          self.__field_fa.readfrombuffer(buf) 
1738          self.__field_faset=UINT(**{'sizeinbytes': 1, 'default': 0x02}) 
1739          self.__field_faset.readfrombuffer(buf) 
1740          self.__field_byte1=UINT(**{'sizeinbytes': 1}) 
1741          self.__field_byte1.readfrombuffer(buf) 
1742          self.__field_byte2=UINT(**{'sizeinbytes': 1}) 
1743          self.__field_byte2.readfrombuffer(buf) 
1744          self.__field_byte3=UINT(**{'sizeinbytes': 2}) 
1745          self.__field_byte3.readfrombuffer(buf) 
1746          self._bufferendoffset=buf.getcurrentoffset() 
1747   
1748   
1749 -    def __getfield_fa(self): 
1750          try: self.__field_fa 
1751          except: 
1752              self.__field_fa=UINT(**{'sizeinbytes': 2, 'constant': 0x00fa}) 
1753          return self.__field_fa.getvalue() 
1754   
1755 -    def __setfield_fa(self, value): 
1756          if isinstance(value,UINT): 
1757              self.__field_fa=value 
1758          else: 
1759              self.__field_fa=UINT(value,**{'sizeinbytes': 2, 'constant': 0x00fa}) 
1760   
1761 -    def __delfield_fa(self): del self.__field_fa 
1762   
1763      fa=property(__getfield_fa, __setfield_fa, __delfield_fa, None) 
1764   
1765 -    def __getfield_faset(self): 
1766          try: self.__field_faset 
1767          except: 
1768              self.__field_faset=UINT(**{'sizeinbytes': 1, 'default': 0x02}) 
1769          return self.__field_faset.getvalue() 
1770   
1771 -    def __setfield_faset(self, value): 
1772          if isinstance(value,UINT): 
1773              self.__field_faset=value 
1774          else: 
1775              self.__field_faset=UINT(value,**{'sizeinbytes': 1, 'default': 0x02}) 
1776   
1777 -    def __delfield_faset(self): del self.__field_faset 
1778   
1779      faset=property(__getfield_faset, __setfield_faset, __delfield_faset, None) 
1780   
1781 -    def __getfield_byte1(self): 
1782          return self.__field_byte1.getvalue() 
1783   
1784 -    def __setfield_byte1(self, value): 
1785          if isinstance(value,UINT): 
1786              self.__field_byte1=value 
1787          else: 
1788              self.__field_byte1=UINT(value,**{'sizeinbytes': 1}) 
1789   
1790 -    def __delfield_byte1(self): del self.__field_byte1 
1791   
1792      byte1=property(__getfield_byte1, __setfield_byte1, __delfield_byte1, None) 
1793   
1794 -    def __getfield_byte2(self): 
1795          return self.__field_byte2.getvalue() 
1796   
1797 -    def __setfield_byte2(self, value): 
1798          if isinstance(value,UINT): 
1799              self.__field_byte2=value 
1800          else: 
1801              self.__field_byte2=UINT(value,**{'sizeinbytes': 1}) 
1802   
1803 -    def __delfield_byte2(self): del self.__field_byte2 
1804   
1805      byte2=property(__getfield_byte2, __setfield_byte2, __delfield_byte2, None) 
1806   
1807 -    def __getfield_byte3(self): 
1808          return self.__field_byte3.getvalue() 
1809   
1810 -    def __setfield_byte3(self, value): 
1811          if isinstance(value,UINT): 
1812              self.__field_byte3=value 
1813          else: 
1814              self.__field_byte3=UINT(value,**{'sizeinbytes': 2}) 
1815   
1816 -    def __delfield_byte3(self): del self.__field_byte3 
1817   
1818      byte3=property(__getfield_byte3, __setfield_byte3, __delfield_byte3, None) 
1819   
1820 -    def iscontainer(self): 
1821          return True 
1822   
1823 -    def containerelements(self): 
1824          yield ('fa', self.__field_fa, None) 
1825          yield ('faset', self.__field_faset, None) 
1826          yield ('byte1', self.__field_byte1, None) 
1827          yield ('byte2', self.__field_byte2, None) 
1828          yield ('byte3', self.__field_byte3, None) 
1829   
1830   
1831   
1832   
1833 -class contactindexrequest(BaseProtogenClass): 
1834      __fields=['header', 'slot'] 
1835   
1836 -    def __init__(self, *args, **kwargs): 
1837          dict={} 
1838          # What was supplied to this function 
1839          dict.update(kwargs) 
1840          # Parent constructor 
1841          super(contactindexrequest,self).__init__(**dict) 
1842          if self.__class__ is contactindexrequest: 
1843              self._update(args,dict) 
1844   
1845   
1846 -    def getfields(self): 
1847          return self.__fields 
1848   
1849   
1850 -    def _update(self, args, kwargs): 
1851          super(contactindexrequest,self)._update(args,kwargs) 
1852          keys=kwargs.keys() 
1853          for key in keys: 
1854              if key in self.__fields: 
1855                  setattr(self, key, kwargs[key]) 
1856                  del kwargs[key] 
1857          # Were any unrecognized kwargs passed in? 
1858          if __debug__: 
1859              self._complainaboutunusedargs(contactindexrequest,kwargs) 
1860          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1861          # Make all P fields that haven't already been constructed 
1862   
1863   
1864 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1865          'Writes this packet to the supplied buffer' 
1866          self._bufferstartoffset=buf.getcurrentoffset() 
1867          try: self.__field_header 
1868          except: 
1869              self.__field_header=sanyoheader(**{'packettype': 0x16,                   'command': 0x88}) 
1870          self.__field_header.writetobuffer(buf) 
1871          self.__field_slot.writetobuffer(buf) 
1872          self._bufferendoffset=buf.getcurrentoffset() 
1873          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1874   
1875   
1876 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1877          'Reads this packet from the supplied buffer' 
1878          self._bufferstartoffset=buf.getcurrentoffset() 
1879          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1880          self.__field_header=sanyoheader(**{'packettype': 0x16,                   'command': 0x88}) 
1881          self.__field_header.readfrombuffer(buf) 
1882          self.__field_slot=UINT(**{'sizeinbytes': 2}) 
1883          self.__field_slot.readfrombuffer(buf) 
1884          self._bufferendoffset=buf.getcurrentoffset() 
1885   
1886   
1887 -    def __getfield_header(self): 
1888          try: self.__field_header 
1889          except: 
1890              self.__field_header=sanyoheader(**{'packettype': 0x16,                   'command': 0x88}) 
1891          return self.__field_header.getvalue() 
1892   
1893 -    def __setfield_header(self, value): 
1894          if isinstance(value,sanyoheader): 
1895              self.__field_header=value 
1896          else: 
1897              self.__field_header=sanyoheader(value,**{'packettype': 0x16,                   'command': 0x88}) 
1898   
1899 -    def __delfield_header(self): del self.__field_header 
1900   
1901      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
1902   
1903 -    def __getfield_slot(self): 
1904          return self.__field_slot.getvalue() 
1905   
1906 -    def __setfield_slot(self, value): 
1907          if isinstance(value,UINT): 
1908              self.__field_slot=value 
1909          else: 
1910              self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 
1911   
1912 -    def __delfield_slot(self): del self.__field_slot 
1913   
1914      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
1915   
1916 -    def iscontainer(self): 
1917          return True 
1918   
1919 -    def containerelements(self): 
1920          yield ('header', self.__field_header, None) 
1921          yield ('slot', self.__field_slot, None) 
1922   
1923   
1924   
1925   
1926 -class contactindexentry(BaseProtogenClass): 
1927      __fields=['groupid', 'slot', 'namep', 'numberps', 'emailps', 'urlp', 'addressp', 'memop', 'ringerid', 'pictureid', 'defaultnum', 'secret'] 
1928   
1929 -    def __init__(self, *args, **kwargs): 
1930          dict={} 
1931          # What was supplied to this function 
1932          dict.update(kwargs) 
1933          # Parent constructor 
1934          super(contactindexentry,self).__init__(**dict) 
1935          if self.__class__ is contactindexentry: 
1936              self._update(args,dict) 
1937   
1938   
1939 -    def getfields(self): 
1940          return self.__fields 
1941   
1942   
1943 -    def _update(self, args, kwargs): 
1944          super(contactindexentry,self)._update(args,kwargs) 
1945          keys=kwargs.keys() 
1946          for key in keys: 
1947              if key in self.__fields: 
1948                  setattr(self, key, kwargs[key]) 
1949                  del kwargs[key] 
1950          # Were any unrecognized kwargs passed in? 
1951          if __debug__: 
1952              self._complainaboutunusedargs(contactindexentry,kwargs) 
1953          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1954          # Make all P fields that haven't already been constructed 
1955   
1956   
1957 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1958          'Writes this packet to the supplied buffer' 
1959          self._bufferstartoffset=buf.getcurrentoffset() 
1960          self.__field_groupid.writetobuffer(buf) 
1961          self.__field_slot.writetobuffer(buf) 
1962          try: self.__field_namep 
1963          except: 
1964              self.__field_namep=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
1965          self.__field_namep.writetobuffer(buf) 
1966          try: self.__field_numberps 
1967          except: 
1968              self.__field_numberps=LIST(**{'elementclass': _gen_p_sanyo6600_143, 'length': NUMPHONENUMBERS}) 
1969          self.__field_numberps.writetobuffer(buf) 
1970          try: self.__field_emailps 
1971          except: 
1972              self.__field_emailps=LIST(**{'elementclass': _gen_p_sanyo6600_145, 'length': NUMEMAILS}) 
1973          self.__field_emailps.writetobuffer(buf) 
1974          try: self.__field_urlp 
1975          except: 
1976              self.__field_urlp=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
1977          self.__field_urlp.writetobuffer(buf) 
1978          try: self.__field_addressp 
1979          except: 
1980              self.__field_addressp=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
1981          self.__field_addressp.writetobuffer(buf) 
1982          try: self.__field_memop 
1983          except: 
1984              self.__field_memop=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
1985          self.__field_memop.writetobuffer(buf) 
1986          try: self.__field_ringerid 
1987          except: 
1988              self.__field_ringerid=UINT(**{'sizeinbytes': 2, 'default': 0xfff0}) 
1989          self.__field_ringerid.writetobuffer(buf) 
1990          try: self.__field_pictureid 
1991          except: 
1992              self.__field_pictureid=UINT(**{'sizeinbytes': 2, 'default': 0xfffe}) 
1993          self.__field_pictureid.writetobuffer(buf) 
1994          try: self.__field_defaultnum 
1995          except: 
1996              self.__field_defaultnum=UINT(**{'sizeinbytes': 2, 'default': 0}) 
1997          self.__field_defaultnum.writetobuffer(buf) 
1998          try: self.__field_secret 
1999          except: 
2000              self.__field_secret=UINT(**{'sizeinbytes': 1, 'default': 0}) 
2001          self.__field_secret.writetobuffer(buf) 
2002          self._bufferendoffset=buf.getcurrentoffset() 
2003          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2004   
2005   
2006 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2007          'Reads this packet from the supplied buffer' 
2008          self._bufferstartoffset=buf.getcurrentoffset() 
2009          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2010          self.__field_groupid=UINT(**{'sizeinbytes': 1}) 
2011          self.__field_groupid.readfrombuffer(buf) 
2012          self.__field_slot=UINT(**{'sizeinbytes': 2}) 
2013          self.__field_slot.readfrombuffer(buf) 
2014          self.__field_namep=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
2015          self.__field_namep.readfrombuffer(buf) 
2016          self.__field_numberps=LIST(**{'elementclass': _gen_p_sanyo6600_143, 'length': NUMPHONENUMBERS}) 
2017          self.__field_numberps.readfrombuffer(buf) 
2018          self.__field_emailps=LIST(**{'elementclass': _gen_p_sanyo6600_145, 'length': NUMEMAILS}) 
2019          self.__field_emailps.readfrombuffer(buf) 
2020          self.__field_urlp=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
2021          self.__field_urlp.readfrombuffer(buf) 
2022          self.__field_addressp=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
2023          self.__field_addressp.readfrombuffer(buf) 
2024          self.__field_memop=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
2025          self.__field_memop.readfrombuffer(buf) 
2026          self.__field_ringerid=UINT(**{'sizeinbytes': 2, 'default': 0xfff0}) 
2027          self.__field_ringerid.readfrombuffer(buf) 
2028          self.__field_pictureid=UINT(**{'sizeinbytes': 2, 'default': 0xfffe}) 
2029          self.__field_pictureid.readfrombuffer(buf) 
2030          self.__field_defaultnum=UINT(**{'sizeinbytes': 2, 'default': 0}) 
2031          self.__field_defaultnum.readfrombuffer(buf) 
2032          self.__field_secret=UINT(**{'sizeinbytes': 1, 'default': 0}) 
2033          self.__field_secret.readfrombuffer(buf) 
2034          self._bufferendoffset=buf.getcurrentoffset() 
2035   
2036   
2037 -    def __getfield_groupid(self): 
2038          return self.__field_groupid.getvalue() 
2039   
2040 -    def __setfield_groupid(self, value): 
2041          if isinstance(value,UINT): 
2042              self.__field_groupid=value 
2043          else: 
2044              self.__field_groupid=UINT(value,**{'sizeinbytes': 1}) 
2045   
2046 -    def __delfield_groupid(self): del self.__field_groupid 
2047   
2048      groupid=property(__getfield_groupid, __setfield_groupid, __delfield_groupid, None) 
2049   
2050 -    def __getfield_slot(self): 
2051          return self.__field_slot.getvalue() 
2052   
2053 -    def __setfield_slot(self, value): 
2054          if isinstance(value,UINT): 
2055              self.__field_slot=value 
2056          else: 
2057              self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 
2058   
2059 -    def __delfield_slot(self): del self.__field_slot 
2060   
2061      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
2062   
2063 -    def __getfield_namep(self): 
2064          try: self.__field_namep 
2065          except: 
2066              self.__field_namep=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
2067          return self.__field_namep.getvalue() 
2068   
2069 -    def __setfield_namep(self, value): 
2070          if isinstance(value,UINT): 
2071              self.__field_namep=value 
2072          else: 
2073              self.__field_namep=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff}) 
2074   
2075 -    def __delfield_namep(self): del self.__field_namep 
2076   
2077      namep=property(__getfield_namep, __setfield_namep, __delfield_namep, None) 
2078   
2079 -    def __getfield_numberps(self): 
2080          try: self.__field_numberps 
2081          except: 
2082              self.__field_numberps=LIST(**{'elementclass': _gen_p_sanyo6600_143, 'length': NUMPHONENUMBERS}) 
2083          return self.__field_numberps.getvalue() 
2084   
2085 -    def __setfield_numberps(self, value): 
2086          if isinstance(value,LIST): 
2087              self.__field_numberps=value 
2088          else: 
2089              self.__field_numberps=LIST(value,**{'elementclass': _gen_p_sanyo6600_143, 'length': NUMPHONENUMBERS}) 
2090   
2091 -    def __delfield_numberps(self): del self.__field_numberps 
2092   
2093      numberps=property(__getfield_numberps, __setfield_numberps, __delfield_numberps, None) 
2094   
2095 -    def __getfield_emailps(self): 
2096          try: self.__field_emailps 
2097          except: 
2098              self.__field_emailps=LIST(**{'elementclass': _gen_p_sanyo6600_145, 'length': NUMEMAILS}) 
2099          return self.__field_emailps.getvalue() 
2100   
2101 -    def __setfield_emailps(self, value): 
2102          if isinstance(value,LIST): 
2103              self.__field_emailps=value 
2104          else: 
2105              self.__field_emailps=LIST(value,**{'elementclass': _gen_p_sanyo6600_145, 'length': NUMEMAILS}) 
2106   
2107 -    def __delfield_emailps(self): del self.__field_emailps 
2108   
2109      emailps=property(__getfield_emailps, __setfield_emailps, __delfield_emailps, None) 
2110   
2111 -    def __getfield_urlp(self): 
2112          try: self.__field_urlp 
2113          except: 
2114              self.__field_urlp=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
2115          return self.__field_urlp.getvalue() 
2116   
2117 -    def __setfield_urlp(self, value): 
2118          if isinstance(value,UINT): 
2119              self.__field_urlp=value 
2120          else: 
2121              self.__field_urlp=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff}) 
2122   
2123 -    def __delfield_urlp(self): del self.__field_urlp 
2124   
2125      urlp=property(__getfield_urlp, __setfield_urlp, __delfield_urlp, None) 
2126   
2127 -    def __getfield_addressp(self): 
2128          try: self.__field_addressp 
2129          except: 
2130              self.__field_addressp=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
2131          return self.__field_addressp.getvalue() 
2132   
2133 -    def __setfield_addressp(self, value): 
2134          if isinstance(value,UINT): 
2135              self.__field_addressp=value 
2136          else: 
2137              self.__field_addressp=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff}) 
2138   
2139 -    def __delfield_addressp(self): del self.__field_addressp 
2140   
2141      addressp=property(__getfield_addressp, __setfield_addressp, __delfield_addressp, None) 
2142   
2143 -    def __getfield_memop(self): 
2144          try: self.__field_memop 
2145          except: 
2146              self.__field_memop=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
2147          return self.__field_memop.getvalue() 
2148   
2149 -    def __setfield_memop(self, value): 
2150          if isinstance(value,UINT): 
2151              self.__field_memop=value 
2152          else: 
2153              self.__field_memop=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff}) 
2154   
2155 -    def __delfield_memop(self): del self.__field_memop 
2156   
2157      memop=property(__getfield_memop, __setfield_memop, __delfield_memop, None) 
2158   
2159 -    def __getfield_ringerid(self): 
2160          try: self.__field_ringerid 
2161          except: 
2162              self.__field_ringerid=UINT(**{'sizeinbytes': 2, 'default': 0xfff0}) 
2163          return self.__field_ringerid.getvalue() 
2164   
2165 -    def __setfield_ringerid(self, value): 
2166          if isinstance(value,UINT): 
2167              self.__field_ringerid=value 
2168          else: 
2169              self.__field_ringerid=UINT(value,**{'sizeinbytes': 2, 'default': 0xfff0}) 
2170   
2171 -    def __delfield_ringerid(self): del self.__field_ringerid 
2172   
2173      ringerid=property(__getfield_ringerid, __setfield_ringerid, __delfield_ringerid, None) 
2174   
2175 -    def __getfield_pictureid(self): 
2176          try: self.__field_pictureid 
2177          except: 
2178              self.__field_pictureid=UINT(**{'sizeinbytes': 2, 'default': 0xfffe}) 
2179          return self.__field_pictureid.getvalue() 
2180   
2181 -    def __setfield_pictureid(self, value): 
2182          if isinstance(value,UINT): 
2183              self.__field_pictureid=value 
2184          else: 
2185              self.__field_pictureid=UINT(value,**{'sizeinbytes': 2, 'default': 0xfffe}) 
2186   
2187 -    def __delfield_pictureid(self): del self.__field_pictureid 
2188   
2189      pictureid=property(__getfield_pictureid, __setfield_pictureid, __delfield_pictureid, None) 
2190   
2191 -    def __getfield_defaultnum(self): 
2192          try: self.__field_defaultnum 
2193          except: 
2194              self.__field_defaultnum=UINT(**{'sizeinbytes': 2, 'default': 0}) 
2195          return self.__field_defaultnum.getvalue() 
2196   
2197 -    def __setfield_defaultnum(self, value): 
2198          if isinstance(value,UINT): 
2199              self.__field_defaultnum=value 
2200          else: 
2201              self.__field_defaultnum=UINT(value,**{'sizeinbytes': 2, 'default': 0}) 
2202   
2203 -    def __delfield_defaultnum(self): del self.__field_defaultnum 
2204   
2205      defaultnum=property(__getfield_defaultnum, __setfield_defaultnum, __delfield_defaultnum, None) 
2206   
2207 -    def __getfield_secret(self): 
2208          try: self.__field_secret 
2209          except: 
2210              self.__field_secret=UINT(**{'sizeinbytes': 1, 'default': 0}) 
2211          return self.__field_secret.getvalue() 
2212   
2213 -    def __setfield_secret(self, value): 
2214          if isinstance(value,UINT): 
2215              self.__field_secret=value 
2216          else: 
2217              self.__field_secret=UINT(value,**{'sizeinbytes': 1, 'default': 0}) 
2218   
2219 -    def __delfield_secret(self): del self.__field_secret 
2220   
2221      secret=property(__getfield_secret, __setfield_secret, __delfield_secret, None) 
2222   
2223 -    def iscontainer(self): 
2224          return True 
2225   
2226 -    def containerelements(self): 
2227          yield ('groupid', self.__field_groupid, None) 
2228          yield ('slot', self.__field_slot, None) 
2229          yield ('namep', self.__field_namep, None) 
2230          yield ('numberps', self.__field_numberps, None) 
2231          yield ('emailps', self.__field_emailps, None) 
2232          yield ('urlp', self.__field_urlp, None) 
2233          yield ('addressp', self.__field_addressp, None) 
2234          yield ('memop', self.__field_memop, None) 
2235          yield ('ringerid', self.__field_ringerid, None) 
2236          yield ('pictureid', self.__field_pictureid, None) 
2237          yield ('defaultnum', self.__field_defaultnum, None) 
2238          yield ('secret', self.__field_secret, None) 
2239   
2240   
2241   
2242   
2243 -class _gen_p_sanyo6600_143(BaseProtogenClass): 
2244      'Anonymous inner class' 
2245      __fields=['slot'] 
2246   
2247 -    def __init__(self, *args, **kwargs): 
2248          dict={} 
2249          # What was supplied to this function 
2250          dict.update(kwargs) 
2251          # Parent constructor 
2252          super(_gen_p_sanyo6600_143,self).__init__(**dict) 
2253          if self.__class__ is _gen_p_sanyo6600_143: 
2254              self._update(args,dict) 
2255   
2256   
2257 -    def getfields(self): 
2258          return self.__fields 
2259   
2260   
2261 -    def _update(self, args, kwargs): 
2262          super(_gen_p_sanyo6600_143,self)._update(args,kwargs) 
2263          keys=kwargs.keys() 
2264          for key in keys: 
2265              if key in self.__fields: 
2266                  setattr(self, key, kwargs[key]) 
2267                  del kwargs[key] 
2268          # Were any unrecognized kwargs passed in? 
2269          if __debug__: 
2270              self._complainaboutunusedargs(_gen_p_sanyo6600_143,kwargs) 
2271          if len(args): 
2272              dict2={'sizeinbytes': 2, 'default': 0xffff} 
2273              dict2.update(kwargs) 
2274              kwargs=dict2 
2275              self.__field_slot=UINT(*args,**dict2) 
2276          # Make all P fields that haven't already been constructed 
2277   
2278   
2279 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2280          'Writes this packet to the supplied buffer' 
2281          self._bufferstartoffset=buf.getcurrentoffset() 
2282          self.__field_slot.writetobuffer(buf) 
2283          self._bufferendoffset=buf.getcurrentoffset() 
2284          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2285   
2286   
2287 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2288          'Reads this packet from the supplied buffer' 
2289          self._bufferstartoffset=buf.getcurrentoffset() 
2290          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2291          self.__field_slot=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
2292          self.__field_slot.readfrombuffer(buf) 
2293          self._bufferendoffset=buf.getcurrentoffset() 
2294   
2295   
2296 -    def __getfield_slot(self): 
2297          return self.__field_slot.getvalue() 
2298   
2299 -    def __setfield_slot(self, value): 
2300          if isinstance(value,UINT): 
2301              self.__field_slot=value 
2302          else: 
2303              self.__field_slot=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff}) 
2304   
2305 -    def __delfield_slot(self): del self.__field_slot 
2306   
2307      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
2308   
2309 -    def iscontainer(self): 
2310          return True 
2311   
2312 -    def containerelements(self): 
2313          yield ('slot', self.__field_slot, None) 
2314   
2315   
2316   
2317   
2318 -class _gen_p_sanyo6600_145(BaseProtogenClass): 
2319      'Anonymous inner class' 
2320      __fields=['slot'] 
2321   
2322 -    def __init__(self, *args, **kwargs): 
2323          dict={} 
2324          # What was supplied to this function 
2325          dict.update(kwargs) 
2326          # Parent constructor 
2327          super(_gen_p_sanyo6600_145,self).__init__(**dict) 
2328          if self.__class__ is _gen_p_sanyo6600_145: 
2329              self._update(args,dict) 
2330   
2331   
2332 -    def getfields(self): 
2333          return self.__fields 
2334   
2335   
2336 -    def _update(self, args, kwargs): 
2337          super(_gen_p_sanyo6600_145,self)._update(args,kwargs) 
2338          keys=kwargs.keys() 
2339          for key in keys: 
2340              if key in self.__fields: 
2341                  setattr(self, key, kwargs[key]) 
2342                  del kwargs[key] 
2343          # Were any unrecognized kwargs passed in? 
2344          if __debug__: 
2345              self._complainaboutunusedargs(_gen_p_sanyo6600_145,kwargs) 
2346          if len(args): 
2347              dict2={'sizeinbytes': 2, 'default': 0xffff} 
2348              dict2.update(kwargs) 
2349              kwargs=dict2 
2350              self.__field_slot=UINT(*args,**dict2) 
2351          # Make all P fields that haven't already been constructed 
2352   
2353   
2354 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2355          'Writes this packet to the supplied buffer' 
2356          self._bufferstartoffset=buf.getcurrentoffset() 
2357          self.__field_slot.writetobuffer(buf) 
2358          self._bufferendoffset=buf.getcurrentoffset() 
2359          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2360   
2361   
2362 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2363          'Reads this packet from the supplied buffer' 
2364          self._bufferstartoffset=buf.getcurrentoffset() 
2365          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2366          self.__field_slot=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
2367          self.__field_slot.readfrombuffer(buf) 
2368          self._bufferendoffset=buf.getcurrentoffset() 
2369   
2370   
2371 -    def __getfield_slot(self): 
2372          return self.__field_slot.getvalue() 
2373   
2374 -    def __setfield_slot(self, value): 
2375          if isinstance(value,UINT): 
2376              self.__field_slot=value 
2377          else: 
2378              self.__field_slot=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff}) 
2379   
2380 -    def __delfield_slot(self): del self.__field_slot 
2381   
2382      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
2383   
2384 -    def iscontainer(self): 
2385          return True 
2386   
2387 -    def containerelements(self): 
2388          yield ('slot', self.__field_slot, None) 
2389   
2390   
2391   
2392   
2393 -class contactindexresponse(BaseProtogenClass): 
2394      __fields=['header', 'slot', 'entry', 'pad'] 
2395   
2396 -    def __init__(self, *args, **kwargs): 
2397          dict={} 
2398          # What was supplied to this function 
2399          dict.update(kwargs) 
2400          # Parent constructor 
2401          super(contactindexresponse,self).__init__(**dict) 
2402          if self.__class__ is contactindexresponse: 
2403              self._update(args,dict) 
2404   
2405   
2406 -    def getfields(self): 
2407          return self.__fields 
2408   
2409   
2410 -    def _update(self, args, kwargs): 
2411          super(contactindexresponse,self)._update(args,kwargs) 
2412          keys=kwargs.keys() 
2413          for key in keys: 
2414              if key in self.__fields: 
2415                  setattr(self, key, kwargs[key]) 
2416                  del kwargs[key] 
2417          # Were any unrecognized kwargs passed in? 
2418          if __debug__: 
2419              self._complainaboutunusedargs(contactindexresponse,kwargs) 
2420          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2421          # Make all P fields that haven't already been constructed 
2422   
2423   
2424 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2425          'Writes this packet to the supplied buffer' 
2426          self._bufferstartoffset=buf.getcurrentoffset() 
2427          self.__field_header.writetobuffer(buf) 
2428          self.__field_slot.writetobuffer(buf) 
2429          self.__field_entry.writetobuffer(buf) 
2430          self.__field_pad.writetobuffer(buf) 
2431          self._bufferendoffset=buf.getcurrentoffset() 
2432          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2433   
2434   
2435 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2436          'Reads this packet from the supplied buffer' 
2437          self._bufferstartoffset=buf.getcurrentoffset() 
2438          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2439          self.__field_header=sanyoheader() 
2440          self.__field_header.readfrombuffer(buf) 
2441          self.__field_slot=UINT(**{'sizeinbytes': 2}) 
2442          self.__field_slot.readfrombuffer(buf) 
2443          self.__field_entry=contactindexentry() 
2444          self.__field_entry.readfrombuffer(buf) 
2445          self.__field_pad=UNKNOWN() 
2446          self.__field_pad.readfrombuffer(buf) 
2447          self._bufferendoffset=buf.getcurrentoffset() 
2448   
2449   
2450 -    def __getfield_header(self): 
2451          return self.__field_header.getvalue() 
2452   
2453 -    def __setfield_header(self, value): 
2454          if isinstance(value,sanyoheader): 
2455              self.__field_header=value 
2456          else: 
2457              self.__field_header=sanyoheader(value,) 
2458   
2459 -    def __delfield_header(self): del self.__field_header 
2460   
2461      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
2462   
2463 -    def __getfield_slot(self): 
2464          return self.__field_slot.getvalue() 
2465   
2466 -    def __setfield_slot(self, value): 
2467          if isinstance(value,UINT): 
2468              self.__field_slot=value 
2469          else: 
2470              self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 
2471   
2472 -    def __delfield_slot(self): del self.__field_slot 
2473   
2474      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
2475   
2476 -    def __getfield_entry(self): 
2477          return self.__field_entry.getvalue() 
2478   
2479 -    def __setfield_entry(self, value): 
2480          if isinstance(value,contactindexentry): 
2481              self.__field_entry=value 
2482          else: 
2483              self.__field_entry=contactindexentry(value,) 
2484   
2485 -    def __delfield_entry(self): del self.__field_entry 
2486   
2487      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
2488   
2489 -    def __getfield_pad(self): 
2490          return self.__field_pad.getvalue() 
2491   
2492 -    def __setfield_pad(self, value): 
2493          if isinstance(value,UNKNOWN): 
2494              self.__field_pad=value 
2495          else: 
2496              self.__field_pad=UNKNOWN(value,) 
2497   
2498 -    def __delfield_pad(self): del self.__field_pad 
2499   
2500      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
2501   
2502 -    def iscontainer(self): 
2503          return True 
2504   
2505 -    def containerelements(self): 
2506          yield ('header', self.__field_header, None) 
2507          yield ('slot', self.__field_slot, None) 
2508          yield ('entry', self.__field_entry, None) 
2509          yield ('pad', self.__field_pad, None) 
2510   
2511   
2512   
2513   
2514 -class contactindexupdaterequest(BaseProtogenClass): 
2515      __fields=['header', 'slot', 'entry'] 
2516   
2517 -    def __init__(self, *args, **kwargs): 
2518          dict={} 
2519          # What was supplied to this function 
2520          dict.update(kwargs) 
2521          # Parent constructor 
2522          super(contactindexupdaterequest,self).__init__(**dict) 
2523          if self.__class__ is contactindexupdaterequest: 
2524              self._update(args,dict) 
2525   
2526   
2527 -    def getfields(self): 
2528          return self.__fields 
2529   
2530   
2531 -    def _update(self, args, kwargs): 
2532          super(contactindexupdaterequest,self)._update(args,kwargs) 
2533          keys=kwargs.keys() 
2534          for key in keys: 
2535              if key in self.__fields: 
2536                  setattr(self, key, kwargs[key]) 
2537                  del kwargs[key] 
2538          # Were any unrecognized kwargs passed in? 
2539          if __debug__: 
2540              self._complainaboutunusedargs(contactindexupdaterequest,kwargs) 
2541          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2542          # Make all P fields that haven't already been constructed 
2543   
2544   
2545 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2546          'Writes this packet to the supplied buffer' 
2547          self._bufferstartoffset=buf.getcurrentoffset() 
2548          try: self.__field_header 
2549          except: 
2550              self.__field_header=sanyowriteheader(**{'packettype': 0x16,                   'command': 0x88}) 
2551          self.__field_header.writetobuffer(buf) 
2552          self.__field_slot.writetobuffer(buf) 
2553          try: self.__field_entry 
2554          except: 
2555              self.__field_entry=contactindexentry() 
2556          self.__field_entry.writetobuffer(buf) 
2557          self._bufferendoffset=buf.getcurrentoffset() 
2558          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2559   
2560   
2561 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2562          'Reads this packet from the supplied buffer' 
2563          self._bufferstartoffset=buf.getcurrentoffset() 
2564          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2565          self.__field_header=sanyowriteheader(**{'packettype': 0x16,                   'command': 0x88}) 
2566          self.__field_header.readfrombuffer(buf) 
2567          self.__field_slot=UINT(**{'sizeinbytes': 2}) 
2568          self.__field_slot.readfrombuffer(buf) 
2569          self.__field_entry=contactindexentry() 
2570          self.__field_entry.readfrombuffer(buf) 
2571          self._bufferendoffset=buf.getcurrentoffset() 
2572   
2573   
2574 -    def __getfield_header(self): 
2575          try: self.__field_header 
2576          except: 
2577              self.__field_header=sanyowriteheader(**{'packettype': 0x16,                   'command': 0x88}) 
2578          return self.__field_header.getvalue() 
2579   
2580 -    def __setfield_header(self, value): 
2581          if isinstance(value,sanyowriteheader): 
2582              self.__field_header=value 
2583          else: 
2584              self.__field_header=sanyowriteheader(value,**{'packettype': 0x16,                   'command': 0x88}) 
2585   
2586 -    def __delfield_header(self): del self.__field_header 
2587   
2588      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
2589   
2590 -    def __getfield_slot(self): 
2591          return self.__field_slot.getvalue() 
2592   
2593 -    def __setfield_slot(self, value): 
2594          if isinstance(value,UINT): 
2595              self.__field_slot=value 
2596          else: 
2597              self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 
2598   
2599 -    def __delfield_slot(self): del self.__field_slot 
2600   
2601      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
2602   
2603 -    def __getfield_entry(self): 
2604          try: self.__field_entry 
2605          except: 
2606              self.__field_entry=contactindexentry() 
2607          return self.__field_entry.getvalue() 
2608   
2609 -    def __setfield_entry(self, value): 
2610          if isinstance(value,contactindexentry): 
2611              self.__field_entry=value 
2612          else: 
2613              self.__field_entry=contactindexentry(value,) 
2614   
2615 -    def __delfield_entry(self): del self.__field_entry 
2616   
2617      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
2618   
2619 -    def iscontainer(self): 
2620          return True 
2621   
2622 -    def containerelements(self): 
2623          yield ('header', self.__field_header, None) 
2624          yield ('slot', self.__field_slot, None) 
2625          yield ('entry', self.__field_entry, None) 
2626   
2627   
2628   
2629   
2630 -class numberrequest(BaseProtogenClass): 
2631      __fields=['header', 'slot'] 
2632   
2633 -    def __init__(self, *args, **kwargs): 
2634          dict={} 
2635          # What was supplied to this function 
2636          dict.update(kwargs) 
2637          # Parent constructor 
2638          super(numberrequest,self).__init__(**dict) 
2639          if self.__class__ is numberrequest: 
2640              self._update(args,dict) 
2641   
2642   
2643 -    def getfields(self): 
2644          return self.__fields 
2645   
2646   
2647 -    def _update(self, args, kwargs): 
2648          super(numberrequest,self)._update(args,kwargs) 
2649          keys=kwargs.keys() 
2650          for key in keys: 
2651              if key in self.__fields: 
2652                  setattr(self, key, kwargs[key]) 
2653                  del kwargs[key] 
2654          # Were any unrecognized kwargs passed in? 
2655          if __debug__: 
2656              self._complainaboutunusedargs(numberrequest,kwargs) 
2657          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2658          # Make all P fields that haven't already been constructed 
2659   
2660   
2661 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2662          'Writes this packet to the supplied buffer' 
2663          self._bufferstartoffset=buf.getcurrentoffset() 
2664          try: self.__field_header 
2665          except: 
2666              self.__field_header=sanyoheader(**{'packettype': 0x16,                   'command': 0x8f}) 
2667          self.__field_header.writetobuffer(buf) 
2668          self.__field_slot.writetobuffer(buf) 
2669          self._bufferendoffset=buf.getcurrentoffset() 
2670          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2671   
2672   
2673 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2674          'Reads this packet from the supplied buffer' 
2675          self._bufferstartoffset=buf.getcurrentoffset() 
2676          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2677          self.__field_header=sanyoheader(**{'packettype': 0x16,                   'command': 0x8f}) 
2678          self.__field_header.readfrombuffer(buf) 
2679          self.__field_slot=UINT(**{'sizeinbytes': 2}) 
2680          self.__field_slot.readfrombuffer(buf) 
2681          self._bufferendoffset=buf.getcurrentoffset() 
2682   
2683   
2684 -    def __getfield_header(self): 
2685          try: self.__field_header 
2686          except: 
2687              self.__field_header=sanyoheader(**{'packettype': 0x16,                   'command': 0x8f}) 
2688          return self.__field_header.getvalue() 
2689   
2690 -    def __setfield_header(self, value): 
2691          if isinstance(value,sanyoheader): 
2692              self.__field_header=value 
2693          else: 
2694              self.__field_header=sanyoheader(value,**{'packettype': 0x16,                   'command': 0x8f}) 
2695   
2696 -    def __delfield_header(self): del self.__field_header 
2697   
2698      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
2699   
2700 -    def __getfield_slot(self): 
2701          return self.__field_slot.getvalue() 
2702   
2703 -    def __setfield_slot(self, value): 
2704          if isinstance(value,UINT): 
2705              self.__field_slot=value 
2706          else: 
2707              self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 
2708   
2709 -    def __delfield_slot(self): del self.__field_slot 
2710   
2711      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
2712   
2713 -    def iscontainer(self): 
2714          return True 
2715   
2716 -    def containerelements(self): 
2717          yield ('header', self.__field_header, None) 
2718          yield ('slot', self.__field_slot, None) 
2719   
2720   
2721   
2722   
2723 -class numberentry(BaseProtogenClass): 
2724      __fields=['contactp', 'numberlen', 'number', 'pad', 'numbertype'] 
2725   
2726 -    def __init__(self, *args, **kwargs): 
2727          dict={} 
2728          # What was supplied to this function 
2729          dict.update(kwargs) 
2730          # Parent constructor 
2731          super(numberentry,self).__init__(**dict) 
2732          if self.__class__ is numberentry: 
2733              self._update(args,dict) 
2734   
2735   
2736 -    def getfields(self): 
2737          return self.__fields 
2738   
2739   
2740 -    def _update(self, args, kwargs): 
2741          super(numberentry,self)._update(args,kwargs) 
2742          keys=kwargs.keys() 
2743          for key in keys: 
2744              if key in self.__fields: 
2745                  setattr(self, key, kwargs[key]) 
2746                  del kwargs[key] 
2747          # Were any unrecognized kwargs passed in? 
2748          if __debug__: 
2749              self._complainaboutunusedargs(numberentry,kwargs) 
2750          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2751          # Make all P fields that haven't already been constructed 
2752   
2753   
2754 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2755          'Writes this packet to the supplied buffer' 
2756          self._bufferstartoffset=buf.getcurrentoffset() 
2757          self.__field_contactp.writetobuffer(buf) 
2758          self.__field_numberlen.writetobuffer(buf) 
2759          try: self.__field_number 
2760          except: 
2761              self.__field_number=USTRING(**{'sizeinbytes': 48, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
2762          self.__field_number.writetobuffer(buf) 
2763          try: self.__field_pad 
2764          except: 
2765              self.__field_pad=UNKNOWN(**{'sizeinbytes': 1}) 
2766          self.__field_pad.writetobuffer(buf) 
2767          self.__field_numbertype.writetobuffer(buf) 
2768          self._bufferendoffset=buf.getcurrentoffset() 
2769          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2770   
2771   
2772 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2773          'Reads this packet from the supplied buffer' 
2774          self._bufferstartoffset=buf.getcurrentoffset() 
2775          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2776          self.__field_contactp=UINT(**{'sizeinbytes': 2}) 
2777          self.__field_contactp.readfrombuffer(buf) 
2778          self.__field_numberlen=UINT(**{'sizeinbytes': 1}) 
2779          self.__field_numberlen.readfrombuffer(buf) 
2780          self.__field_number=USTRING(**{'sizeinbytes': 48, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
2781          self.__field_number.readfrombuffer(buf) 
2782          self.__field_pad=UNKNOWN(**{'sizeinbytes': 1}) 
2783          self.__field_pad.readfrombuffer(buf) 
2784          self.__field_numbertype=UINT(**{'sizeinbytes': 1}) 
2785          self.__field_numbertype.readfrombuffer(buf) 
2786          self._bufferendoffset=buf.getcurrentoffset() 
2787   
2788   
2789 -    def __getfield_contactp(self): 
2790          return self.__field_contactp.getvalue() 
2791   
2792 -    def __setfield_contactp(self, value): 
2793          if isinstance(value,UINT): 
2794              self.__field_contactp=value 
2795          else: 
2796              self.__field_contactp=UINT(value,**{'sizeinbytes': 2}) 
2797   
2798 -    def __delfield_contactp(self): del self.__field_contactp 
2799   
2800      contactp=property(__getfield_contactp, __setfield_contactp, __delfield_contactp, "Pointer to contact number belongs") 
2801   
2802 -    def __getfield_numberlen(self): 
2803          return self.__field_numberlen.getvalue() 
2804   
2805 -    def __setfield_numberlen(self, value): 
2806          if isinstance(value,UINT): 
2807              self.__field_numberlen=value 
2808          else: 
2809              self.__field_numberlen=UINT(value,**{'sizeinbytes': 1}) 
2810   
2811 -    def __delfield_numberlen(self): del self.__field_numberlen 
2812   
2813      numberlen=property(__getfield_numberlen, __setfield_numberlen, __delfield_numberlen, None) 
2814   
2815 -    def __getfield_number(self): 
2816          try: self.__field_number 
2817          except: 
2818              self.__field_number=USTRING(**{'sizeinbytes': 48, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
2819          return self.__field_number.getvalue() 
2820   
2821 -    def __setfield_number(self, value): 
2822          if isinstance(value,USTRING): 
2823              self.__field_number=value 
2824          else: 
2825              self.__field_number=USTRING(value,**{'sizeinbytes': 48, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
2826   
2827 -    def __delfield_number(self): del self.__field_number 
2828   
2829      number=property(__getfield_number, __setfield_number, __delfield_number, None) 
2830   
2831 -    def __getfield_pad(self): 
2832          try: self.__field_pad 
2833          except: 
2834              self.__field_pad=UNKNOWN(**{'sizeinbytes': 1}) 
2835          return self.__field_pad.getvalue() 
2836   
2837 -    def __setfield_pad(self, value): 
2838          if isinstance(value,UNKNOWN): 
2839              self.__field_pad=value 
2840          else: 
2841              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 1}) 
2842   
2843 -    def __delfield_pad(self): del self.__field_pad 
2844   
2845      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
2846   
2847 -    def __getfield_numbertype(self): 
2848          return self.__field_numbertype.getvalue() 
2849   
2850 -    def __setfield_numbertype(self, value): 
2851          if isinstance(value,UINT): 
2852              self.__field_numbertype=value 
2853          else: 
2854              self.__field_numbertype=UINT(value,**{'sizeinbytes': 1}) 
2855   
2856 -    def __delfield_numbertype(self): del self.__field_numbertype 
2857   
2858      numbertype=property(__getfield_numbertype, __setfield_numbertype, __delfield_numbertype, None) 
2859   
2860 -    def iscontainer(self): 
2861          return True 
2862   
2863 -    def containerelements(self): 
2864          yield ('contactp', self.__field_contactp, "Pointer to contact number belongs") 
2865          yield ('numberlen', self.__field_numberlen, None) 
2866          yield ('number', self.__field_number, None) 
2867          yield ('pad', self.__field_pad, None) 
2868          yield ('numbertype', self.__field_numbertype, None) 
2869   
2870   
2871   
2872   
2873 -class numberresponse(BaseProtogenClass): 
2874      __fields=['header', 'slot', 'entry', 'pad'] 
2875   
2876 -    def __init__(self, *args, **kwargs): 
2877          dict={} 
2878          # What was supplied to this function 
2879          dict.update(kwargs) 
2880          # Parent constructor 
2881          super(numberresponse,self).__init__(**dict) 
2882          if self.__class__ is numberresponse: 
2883              self._update(args,dict) 
2884   
2885   
2886 -    def getfields(self): 
2887          return self.__fields 
2888   
2889   
2890 -    def _update(self, args, kwargs): 
2891          super(numberresponse,self)._update(args,kwargs) 
2892          keys=kwargs.keys() 
2893          for key in keys: 
2894              if key in self.__fields: 
2895                  setattr(self, key, kwargs[key]) 
2896                  del kwargs[key] 
2897          # Were any unrecognized kwargs passed in? 
2898          if __debug__: 
2899              self._complainaboutunusedargs(numberresponse,kwargs) 
2900          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2901          # Make all P fields that haven't already been constructed 
2902   
2903   
2904 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2905          'Writes this packet to the supplied buffer' 
2906          self._bufferstartoffset=buf.getcurrentoffset() 
2907          self.__field_header.writetobuffer(buf) 
2908          self.__field_slot.writetobuffer(buf) 
2909          self.__field_entry.writetobuffer(buf) 
2910          self.__field_pad.writetobuffer(buf) 
2911          self._bufferendoffset=buf.getcurrentoffset() 
2912          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2913   
2914   
2915 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2916          'Reads this packet from the supplied buffer' 
2917          self._bufferstartoffset=buf.getcurrentoffset() 
2918          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2919          self.__field_header=sanyoheader() 
2920          self.__field_header.readfrombuffer(buf) 
2921          self.__field_slot=UINT(**{'sizeinbytes': 2}) 
2922          self.__field_slot.readfrombuffer(buf) 
2923          self.__field_entry=numberentry() 
2924          self.__field_entry.readfrombuffer(buf) 
2925          self.__field_pad=UNKNOWN() 
2926          self.__field_pad.readfrombuffer(buf) 
2927          self._bufferendoffset=buf.getcurrentoffset() 
2928   
2929   
2930 -    def __getfield_header(self): 
2931          return self.__field_header.getvalue() 
2932   
2933 -    def __setfield_header(self, value): 
2934          if isinstance(value,sanyoheader): 
2935              self.__field_header=value 
2936          else: 
2937              self.__field_header=sanyoheader(value,) 
2938   
2939 -    def __delfield_header(self): del self.__field_header 
2940   
2941      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
2942   
2943 -    def __getfield_slot(self): 
2944          return self.__field_slot.getvalue() 
2945   
2946 -    def __setfield_slot(self, value): 
2947          if isinstance(value,UINT): 
2948              self.__field_slot=value 
2949          else: 
2950              self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 
2951   
2952 -    def __delfield_slot(self): del self.__field_slot 
2953   
2954      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
2955   
2956 -    def __getfield_entry(self): 
2957          return self.__field_entry.getvalue() 
2958   
2959 -    def __setfield_entry(self, value): 
2960          if isinstance(value,numberentry): 
2961              self.__field_entry=value 
2962          else: 
2963              self.__field_entry=numberentry(value,) 
2964   
2965 -    def __delfield_entry(self): del self.__field_entry 
2966   
2967      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
2968   
2969 -    def __getfield_pad(self): 
2970          return self.__field_pad.getvalue() 
2971   
2972 -    def __setfield_pad(self, value): 
2973          if isinstance(value,UNKNOWN): 
2974              self.__field_pad=value 
2975          else: 
2976              self.__field_pad=UNKNOWN(value,) 
2977   
2978 -    def __delfield_pad(self): del self.__field_pad 
2979   
2980      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
2981   
2982 -    def iscontainer(self): 
2983          return True 
2984   
2985 -    def containerelements(self): 
2986          yield ('header', self.__field_header, None) 
2987          yield ('slot', self.__field_slot, None) 
2988          yield ('entry', self.__field_entry, None) 
2989          yield ('pad', self.__field_pad, None) 
2990   
2991   
2992   
2993   
2994 -class numberupdaterequest(BaseProtogenClass): 
2995      __fields=['header', 'slot', 'entry'] 
2996   
2997 -    def __init__(self, *args, **kwargs): 
2998          dict={} 
2999          # What was supplied to this function 
3000          dict.update(kwargs) 
3001          # Parent constructor 
3002          super(numberupdaterequest,self).__init__(**dict) 
3003          if self.__class__ is numberupdaterequest: 
3004              self._update(args,dict) 
3005   
3006   
3007 -    def getfields(self): 
3008          return self.__fields 
3009   
3010   
3011 -    def _update(self, args, kwargs): 
3012          super(numberupdaterequest,self)._update(args,kwargs) 
3013          keys=kwargs.keys() 
3014          for key in keys: 
3015              if key in self.__fields: 
3016                  setattr(self, key, kwargs[key]) 
3017                  del kwargs[key] 
3018          # Were any unrecognized kwargs passed in? 
3019          if __debug__: 
3020              self._complainaboutunusedargs(numberupdaterequest,kwargs) 
3021          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
3022          # Make all P fields that haven't already been constructed 
3023   
3024   
3025 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3026          'Writes this packet to the supplied buffer' 
3027          self._bufferstartoffset=buf.getcurrentoffset() 
3028          try: self.__field_header 
3029          except: 
3030              self.__field_header=sanyowriteheader(**{'packettype': 0x16,                   'command': 0x8f}) 
3031          self.__field_header.writetobuffer(buf) 
3032          self.__field_slot.writetobuffer(buf) 
3033          try: self.__field_entry 
3034          except: 
3035              self.__field_entry=numberentry() 
3036          self.__field_entry.writetobuffer(buf) 
3037          self._bufferendoffset=buf.getcurrentoffset() 
3038          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3039   
3040   
3041 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3042          'Reads this packet from the supplied buffer' 
3043          self._bufferstartoffset=buf.getcurrentoffset() 
3044          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3045          self.__field_header=sanyowriteheader(**{'packettype': 0x16,                   'command': 0x8f}) 
3046          self.__field_header.readfrombuffer(buf) 
3047          self.__field_slot=UINT(**{'sizeinbytes': 2}) 
3048          self.__field_slot.readfrombuffer(buf) 
3049          self.__field_entry=numberentry() 
3050          self.__field_entry.readfrombuffer(buf) 
3051          self._bufferendoffset=buf.getcurrentoffset() 
3052   
3053   
3054 -    def __getfield_header(self): 
3055          try: self.__field_header 
3056          except: 
3057              self.__field_header=sanyowriteheader(**{'packettype': 0x16,                   'command': 0x8f}) 
3058          return self.__field_header.getvalue() 
3059   
3060 -    def __setfield_header(self, value): 
3061          if isinstance(value,sanyowriteheader): 
3062              self.__field_header=value 
3063          else: 
3064              self.__field_header=sanyowriteheader(value,**{'packettype': 0x16,                   'command': 0x8f}) 
3065   
3066 -    def __delfield_header(self): del self.__field_header 
3067   
3068      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
3069   
3070 -    def __getfield_slot(self): 
3071          return self.__field_slot.getvalue() 
3072   
3073 -    def __setfield_slot(self, value): 
3074          if isinstance(value,UINT): 
3075              self.__field_slot=value 
3076          else: 
3077              self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 
3078   
3079 -    def __delfield_slot(self): del self.__field_slot 
3080   
3081      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
3082   
3083 -    def __getfield_entry(self): 
3084          try: self.__field_entry 
3085          except: 
3086              self.__field_entry=numberentry() 
3087          return self.__field_entry.getvalue() 
3088   
3089 -    def __setfield_entry(self, value): 
3090          if isinstance(value,numberentry): 
3091              self.__field_entry=value 
3092          else: 
3093              self.__field_entry=numberentry(value,) 
3094   
3095 -    def __delfield_entry(self): del self.__field_entry 
3096   
3097      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
3098   
3099 -    def iscontainer(self): 
3100          return True 
3101   
3102 -    def containerelements(self): 
3103          yield ('header', self.__field_header, None) 
3104          yield ('slot', self.__field_slot, None) 
3105          yield ('entry', self.__field_entry, None) 
3106   
3107   
3108   
3109   
3110 -class namerequest(BaseProtogenClass): 
3111      __fields=['header', 'slot'] 
3112   
3113 -    def __init__(self, *args, **kwargs): 
3114          dict={} 
3115          # What was supplied to this function 
3116          dict.update(kwargs) 
3117          # Parent constructor 
3118          super(namerequest,self).__init__(**dict) 
3119          if self.__class__ is namerequest: 
3120              self._update(args,dict) 
3121   
3122   
3123 -    def getfields(self): 
3124          return self.__fields 
3125   
3126   
3127 -    def _update(self, args, kwargs): 
3128          super(namerequest,self)._update(args,kwargs) 
3129          keys=kwargs.keys() 
3130          for key in keys: 
3131              if key in self.__fields: 
3132                  setattr(self, key, kwargs[key]) 
3133                  del kwargs[key] 
3134          # Were any unrecognized kwargs passed in? 
3135          if __debug__: 
3136              self._complainaboutunusedargs(namerequest,kwargs) 
3137          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
3138          # Make all P fields that haven't already been constructed 
3139   
3140   
3141 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3142          'Writes this packet to the supplied buffer' 
3143          self._bufferstartoffset=buf.getcurrentoffset() 
3144          try: self.__field_header 
3145          except: 
3146              self.__field_header=sanyoheader(**{'packettype': 0x16,                   'command': 0x8c}) 
3147          self.__field_header.writetobuffer(buf) 
3148          self.__field_slot.writetobuffer(buf) 
3149          self._bufferendoffset=buf.getcurrentoffset() 
3150          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3151   
3152   
3153 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3154          'Reads this packet from the supplied buffer' 
3155          self._bufferstartoffset=buf.getcurrentoffset() 
3156          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3157          self.__field_header=sanyoheader(**{'packettype': 0x16,                   'command': 0x8c}) 
3158          self.__field_header.readfrombuffer(buf) 
3159          self.__field_slot=UINT(**{'sizeinbytes': 2}) 
3160          self.__field_slot.readfrombuffer(buf) 
3161          self._bufferendoffset=buf.getcurrentoffset() 
3162   
3163   
3164 -    def __getfield_header(self): 
3165          try: self.__field_header 
3166          except: 
3167              self.__field_header=sanyoheader(**{'packettype': 0x16,                   'command': 0x8c}) 
3168          return self.__field_header.getvalue() 
3169   
3170 -    def __setfield_header(self, value): 
3171          if isinstance(value,sanyoheader): 
3172              self.__field_header=value 
3173          else: 
3174              self.__field_header=sanyoheader(value,**{'packettype': 0x16,                   'command': 0x8c}) 
3175   
3176 -    def __delfield_header(self): del self.__field_header 
3177   
3178      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
3179   
3180 -    def __getfield_slot(self): 
3181          return self.__field_slot.getvalue() 
3182   
3183 -    def __setfield_slot(self, value): 
3184          if isinstance(value,UINT): 
3185              self.__field_slot=value 
3186          else: 
3187              self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 
3188   
3189 -    def __delfield_slot(self): del self.__field_slot 
3190   
3191      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
3192   
3193 -    def iscontainer(self): 
3194          return True 
3195   
3196 -    def containerelements(self): 
3197          yield ('header', self.__field_header, None) 
3198          yield ('slot', self.__field_slot, None) 
3199   
3200   
3201   
3202   
3203 -class nameentry(BaseProtogenClass): 
3204      __fields=['contactp', 'name_len', 'name_len2', 'name'] 
3205   
3206 -    def __init__(self, *args, **kwargs): 
3207          dict={} 
3208          # What was supplied to this function 
3209          dict.update(kwargs) 
3210          # Parent constructor 
3211          super(nameentry,self).__init__(**dict) 
3212          if self.__class__ is nameentry: 
3213              self._update(args,dict) 
3214   
3215   
3216 -    def getfields(self): 
3217          return self.__fields 
3218   
3219   
3220 -    def _update(self, args, kwargs): 
3221          super(nameentry,self)._update(args,kwargs) 
3222          keys=kwargs.keys() 
3223          for key in keys: 
3224              if key in self.__fields: 
3225                  setattr(self, key, kwargs[key]) 
3226                  del kwargs[key] 
3227          # Were any unrecognized kwargs passed in? 
3228          if __debug__: 
3229              self._complainaboutunusedargs(nameentry,kwargs) 
3230          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
3231          # Make all P fields that haven't already been constructed 
3232   
3233   
3234 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3235          'Writes this packet to the supplied buffer' 
3236          self._bufferstartoffset=buf.getcurrentoffset() 
3237          self.__field_contactp.writetobuffer(buf) 
3238          self.__field_name_len.writetobuffer(buf) 
3239          self.__field_name_len2.writetobuffer(buf) 
3240          self.__field_name.writetobuffer(buf) 
3241          self._bufferendoffset=buf.getcurrentoffset() 
3242          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3243   
3244   
3245 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3246          'Reads this packet from the supplied buffer' 
3247          self._bufferstartoffset=buf.getcurrentoffset() 
3248          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3249          self.__field_contactp=UINT(**{'sizeinbytes': 2}) 
3250          self.__field_contactp.readfrombuffer(buf) 
3251          self.__field_name_len=UINT(**{'sizeinbytes': 1}) 
3252          self.__field_name_len.readfrombuffer(buf) 
3253          self.__field_name_len2=UINT(**{'sizeinbytes': 1}) 
3254          self.__field_name_len2.readfrombuffer(buf) 
3255          self.__field_name=USTRING(**{'sizeinbytes': 32, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
3256          self.__field_name.readfrombuffer(buf) 
3257          self._bufferendoffset=buf.getcurrentoffset() 
3258   
3259   
3260 -    def __getfield_contactp(self): 
3261          return self.__field_contactp.getvalue() 
3262   
3263 -    def __setfield_contactp(self, value): 
3264          if isinstance(value,UINT): 
3265              self.__field_contactp=value 
3266          else: 
3267              self.__field_contactp=UINT(value,**{'sizeinbytes': 2}) 
3268   
3269 -    def __delfield_contactp(self): del self.__field_contactp 
3270   
3271      contactp=property(__getfield_contactp, __setfield_contactp, __delfield_contactp, None) 
3272   
3273 -    def __getfield_name_len(self): 
3274          return self.__field_name_len.getvalue() 
3275   
3276 -    def __setfield_name_len(self, value): 
3277          if isinstance(value,UINT): 
3278              self.__field_name_len=value 
3279          else: 
3280              self.__field_name_len=UINT(value,**{'sizeinbytes': 1}) 
3281   
3282 -    def __delfield_name_len(self): del self.__field_name_len 
3283   
3284      name_len=property(__getfield_name_len, __setfield_name_len, __delfield_name_len, None) 
3285   
3286 -    def __getfield_name_len2(self): 
3287          return self.__field_name_len2.getvalue() 
3288   
3289 -    def __setfield_name_len2(self, value): 
3290          if isinstance(value,UINT): 
3291              self.__field_name_len2=value 
3292          else: 
3293              self.__field_name_len2=UINT(value,**{'sizeinbytes': 1}) 
3294   
3295 -    def __delfield_name_len2(self): del self.__field_name_len2 
3296   
3297      name_len2=property(__getfield_name_len2, __setfield_name_len2, __delfield_name_len2, None) 
3298   
3299 -    def __getfield_name(self): 
3300          return self.__field_name.getvalue() 
3301   
3302 -    def __setfield_name(self, value): 
3303          if isinstance(value,USTRING): 
3304              self.__field_name=value 
3305          else: 
3306              self.__field_name=USTRING(value,**{'sizeinbytes': 32, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
3307   
3308 -    def __delfield_name(self): del self.__field_name 
3309   
3310      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
3311   
3312 -    def iscontainer(self): 
3313          return True 
3314   
3315 -    def containerelements(self): 
3316          yield ('contactp', self.__field_contactp, None) 
3317          yield ('name_len', self.__field_name_len, None) 
3318          yield ('name_len2', self.__field_name_len2, None) 
3319          yield ('name', self.__field_name, None) 
3320   
3321   
3322   
3323   
3324 -class nameresponse(BaseProtogenClass): 
3325      __fields=['header', 'slot', 'entry', 'pad'] 
3326   
3327 -    def __init__(self, *args, **kwargs): 
3328          dict={} 
3329          # What was supplied to this function 
3330          dict.update(kwargs) 
3331          # Parent constructor 
3332          super(nameresponse,self).__init__(**dict) 
3333          if self.__class__ is nameresponse: 
3334              self._update(args,dict) 
3335   
3336   
3337 -    def getfields(self): 
3338          return self.__fields 
3339   
3340   
3341 -    def _update(self, args, kwargs): 
3342          super(nameresponse,self)._update(args,kwargs) 
3343          keys=kwargs.keys() 
3344          for key in keys: 
3345              if key in self.__fields: 
3346                  setattr(self, key, kwargs[key]) 
3347                  del kwargs[key] 
3348          # Were any unrecognized kwargs passed in? 
3349          if __debug__: 
3350              self._complainaboutunusedargs(nameresponse,kwargs) 
3351          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
3352          # Make all P fields that haven't already been constructed 
3353   
3354   
3355 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3356          'Writes this packet to the supplied buffer' 
3357          self._bufferstartoffset=buf.getcurrentoffset() 
3358          self.__field_header.writetobuffer(buf) 
3359          self.__field_slot.writetobuffer(buf) 
3360          self.__field_entry.writetobuffer(buf) 
3361          self.__field_pad.writetobuffer(buf) 
3362          self._bufferendoffset=buf.getcurrentoffset() 
3363          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3364   
3365   
3366 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3367          'Reads this packet from the supplied buffer' 
3368          self._bufferstartoffset=buf.getcurrentoffset() 
3369          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3370          self.__field_header=sanyoheader() 
3371          self.__field_header.readfrombuffer(buf) 
3372          self.__field_slot=UINT(**{'sizeinbytes': 2}) 
3373          self.__field_slot.readfrombuffer(buf) 
3374          self.__field_entry=nameentry() 
3375          self.__field_entry.readfrombuffer(buf) 
3376          self.__field_pad=UNKNOWN() 
3377          self.__field_pad.readfrombuffer(buf) 
3378          self._bufferendoffset=buf.getcurrentoffset() 
3379   
3380   
3381 -    def __getfield_header(self): 
3382          return self.__field_header.getvalue() 
3383   
3384 -    def __setfield_header(self, value): 
3385          if isinstance(value,sanyoheader): 
3386              self.__field_header=value 
3387          else: 
3388              self.__field_header=sanyoheader(value,) 
3389   
3390 -    def __delfield_header(self): del self.__field_header 
3391   
3392      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
3393   
3394 -    def __getfield_slot(self): 
3395          return self.__field_slot.getvalue() 
3396   
3397 -    def __setfield_slot(self, value): 
3398          if isinstance(value,UINT): 
3399              self.__field_slot=value 
3400          else: 
3401              self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 
3402   
3403 -    def __delfield_slot(self): del self.__field_slot 
3404   
3405      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
3406   
3407 -    def __getfield_entry(self): 
3408          return self.__field_entry.getvalue() 
3409   
3410 -    def __setfield_entry(self, value): 
3411          if isinstance(value,nameentry): 
3412              self.__field_entry=value 
3413          else: 
3414              self.__field_entry=nameentry(value,) 
3415   
3416 -    def __delfield_entry(self): del self.__field_entry 
3417   
3418      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
3419   
3420 -    def __getfield_pad(self): 
3421          return self.__field_pad.getvalue() 
3422   
3423 -    def __setfield_pad(self, value): 
3424          if isinstance(value,UNKNOWN): 
3425              self.__field_pad=value 
3426          else: 
3427              self.__field_pad=UNKNOWN(value,) 
3428   
3429 -    def __delfield_pad(self): del self.__field_pad 
3430   
3431      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
3432   
3433 -    def iscontainer(self): 
3434          return True 
3435   
3436 -    def containerelements(self): 
3437          yield ('header', self.__field_header, None) 
3438          yield ('slot', self.__field_slot, None) 
3439          yield ('entry', self.__field_entry, None) 
3440          yield ('pad', self.__field_pad, None) 
3441   
3442   
3443   
3444   
3445 -class nameupdaterequest(BaseProtogenClass): 
3446      __fields=['header', 'slot', 'entry'] 
3447   
3448 -    def __init__(self, *args, **kwargs): 
3449          dict={} 
3450          # What was supplied to this function 
3451          dict.update(kwargs) 
3452          # Parent constructor 
3453          super(nameupdaterequest,self).__init__(**dict) 
3454          if self.__class__ is nameupdaterequest: 
3455              self._update(args,dict) 
3456   
3457   
3458 -    def getfields(self): 
3459          return self.__fields 
3460   
3461   
3462 -    def _update(self, args, kwargs): 
3463          super(nameupdaterequest,self)._update(args,kwargs) 
3464          keys=kwargs.keys() 
3465          for key in keys: 
3466              if key in self.__fields: 
3467                  setattr(self, key, kwargs[key]) 
3468                  del kwargs[key] 
3469          # Were any unrecognized kwargs passed in? 
3470          if __debug__: 
3471              self._complainaboutunusedargs(nameupdaterequest,kwargs) 
3472          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
3473          # Make all P fields that haven't already been constructed 
3474   
3475   
3476 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3477          'Writes this packet to the supplied buffer' 
3478          self._bufferstartoffset=buf.getcurrentoffset() 
3479          try: self.__field_header 
3480          except: 
3481              self.__field_header=sanyowriteheader(**{'packettype': 0x16,                   'command': 0x8c}) 
3482          self.__field_header.writetobuffer(buf) 
3483          self.__field_slot.writetobuffer(buf) 
3484          try: self.__field_entry 
3485          except: 
3486              self.__field_entry=nameentry() 
3487          self.__field_entry.writetobuffer(buf) 
3488          self._bufferendoffset=buf.getcurrentoffset() 
3489          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3490   
3491   
3492 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3493          'Reads this packet from the supplied buffer' 
3494          self._bufferstartoffset=buf.getcurrentoffset() 
3495          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3496          self.__field_header=sanyowriteheader(**{'packettype': 0x16,                   'command': 0x8c}) 
3497          self.__field_header.readfrombuffer(buf) 
3498          self.__field_slot=UINT(**{'sizeinbytes': 2}) 
3499          self.__field_slot.readfrombuffer(buf) 
3500          self.__field_entry=nameentry() 
3501          self.__field_entry.readfrombuffer(buf) 
3502          self._bufferendoffset=buf.getcurrentoffset() 
3503   
3504   
3505 -    def __getfield_header(self): 
3506          try: self.__field_header 
3507          except: 
3508              self.__field_header=sanyowriteheader(**{'packettype': 0x16,                   'command': 0x8c}) 
3509          return self.__field_header.getvalue() 
3510   
3511 -    def __setfield_header(self, value): 
3512          if isinstance(value,sanyowriteheader): 
3513              self.__field_header=value 
3514          else: 
3515              self.__field_header=sanyowriteheader(value,**{'packettype': 0x16,                   'command': 0x8c}) 
3516   
3517 -    def __delfield_header(self): del self.__field_header 
3518   
3519      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
3520   
3521 -    def __getfield_slot(self): 
3522          return self.__field_slot.getvalue() 
3523   
3524 -    def __setfield_slot(self, value): 
3525          if isinstance(value,UINT): 
3526              self.__field_slot=value 
3527          else: 
3528              self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 
3529   
3530 -    def __delfield_slot(self): del self.__field_slot 
3531   
3532      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
3533   
3534 -    def __getfield_entry(self): 
3535          try: self.__field_entry 
3536          except: 
3537              self.__field_entry=nameentry() 
3538          return self.__field_entry.getvalue() 
3539   
3540 -    def __setfield_entry(self, value): 
3541          if isinstance(value,nameentry): 
3542              self.__field_entry=value 
3543          else: 
3544              self.__field_entry=nameentry(value,) 
3545   
3546 -    def __delfield_entry(self): del self.__field_entry 
3547   
3548      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
3549   
3550 -    def iscontainer(self): 
3551          return True 
3552   
3553 -    def containerelements(self): 
3554          yield ('header', self.__field_header, None) 
3555          yield ('slot', self.__field_slot, None) 
3556          yield ('entry', self.__field_entry, None) 
3557   
3558   
3559   
3560   
3561 -class urlrequest(BaseProtogenClass): 
3562      __fields=['header', 'slot'] 
3563   
3564 -    def __init__(self, *args, **kwargs): 
3565          dict={} 
3566          # What was supplied to this function 
3567          dict.update(kwargs) 
3568          # Parent constructor 
3569          super(urlrequest,self).__init__(**dict) 
3570          if self.__class__ is urlrequest: 
3571              self._update(args,dict) 
3572   
3573   
3574 -    def getfields(self): 
3575          return self.__fields 
3576   
3577   
3578 -    def _update(self, args, kwargs): 
3579          super(urlrequest,self)._update(args,kwargs) 
3580          keys=kwargs.keys() 
3581          for key in keys: 
3582              if key in self.__fields: 
3583                  setattr(self, key, kwargs[key]) 
3584                  del kwargs[key] 
3585          # Were any unrecognized kwargs passed in? 
3586          if __debug__: 
3587              self._complainaboutunusedargs(urlrequest,kwargs) 
3588          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
3589          # Make all P fields that haven't already been constructed 
3590   
3591   
3592 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3593          'Writes this packet to the supplied buffer' 
3594          self._bufferstartoffset=buf.getcurrentoffset() 
3595          try: self.__field_header 
3596          except: 
3597              self.__field_header=sanyoheader(**{'packettype': 0x16,                   'command': 0x98}) 
3598          self.__field_header.writetobuffer(buf) 
3599          self.__field_slot.writetobuffer(buf) 
3600          self._bufferendoffset=buf.getcurrentoffset() 
3601          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3602   
3603   
3604 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3605          'Reads this packet from the supplied buffer' 
3606          self._bufferstartoffset=buf.getcurrentoffset() 
3607          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3608          self.__field_header=sanyoheader(**{'packettype': 0x16,                   'command': 0x98}) 
3609          self.__field_header.readfrombuffer(buf) 
3610          self.__field_slot=UINT(**{'sizeinbytes': 2}) 
3611          self.__field_slot.readfrombuffer(buf) 
3612          self._bufferendoffset=buf.getcurrentoffset() 
3613   
3614   
3615 -    def __getfield_header(self): 
3616          try: self.__field_header 
3617          except: 
3618              self.__field_header=sanyoheader(**{'packettype': 0x16,                   'command': 0x98}) 
3619          return self.__field_header.getvalue() 
3620   
3621 -    def __setfield_header(self, value): 
3622          if isinstance(value,sanyoheader): 
3623              self.__field_header=value 
3624          else: 
3625              self.__field_header=sanyoheader(value,**{'packettype': 0x16,                   'command': 0x98}) 
3626   
3627 -    def __delfield_header(self): del self.__field_header 
3628   
3629      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
3630   
3631 -    def __getfield_slot(self): 
3632          return self.__field_slot.getvalue() 
3633   
3634 -    def __setfield_slot(self, value): 
3635          if isinstance(value,UINT): 
3636              self.__field_slot=value 
3637          else: 
3638              self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 
3639   
3640 -    def __delfield_slot(self): del self.__field_slot 
3641   
3642      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
3643   
3644 -    def iscontainer(self): 
3645          return True 
3646   
3647 -    def containerelements(self): 
3648          yield ('header', self.__field_header, None) 
3649          yield ('slot', self.__field_slot, None) 
3650   
3651   
3652   
3653   
3654 -class urlentry(BaseProtogenClass): 
3655      __fields=['contactp', 'url_len', 'url', 'pad', 'type'] 
3656   
3657 -    def __init__(self, *args, **kwargs): 
3658          dict={} 
3659          # What was supplied to this function 
3660          dict.update(kwargs) 
3661          # Parent constructor 
3662          super(urlentry,self).__init__(**dict) 
3663          if self.__class__ is urlentry: 
3664              self._update(args,dict) 
3665   
3666   
3667 -    def getfields(self): 
3668          return self.__fields 
3669   
3670   
3671 -    def _update(self, args, kwargs): 
3672          super(urlentry,self)._update(args,kwargs) 
3673          keys=kwargs.keys() 
3674          for key in keys: 
3675              if key in self.__fields: 
3676                  setattr(self, key, kwargs[key]) 
3677                  del kwargs[key] 
3678          # Were any unrecognized kwargs passed in? 
3679          if __debug__: 
3680              self._complainaboutunusedargs(urlentry,kwargs) 
3681          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
3682          # Make all P fields that haven't already been constructed 
3683   
3684   
3685 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3686          'Writes this packet to the supplied buffer' 
3687          self._bufferstartoffset=buf.getcurrentoffset() 
3688          self.__field_contactp.writetobuffer(buf) 
3689          self.__field_url_len.writetobuffer(buf) 
3690          try: self.__field_url 
3691          except: 
3692              self.__field_url=USTRING(**{'sizeinbytes': 96, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
3693          self.__field_url.writetobuffer(buf) 
3694          try: self.__field_pad 
3695          except: 
3696              self.__field_pad=UNKNOWN(**{'sizeinbytes': 1}) 
3697          self.__field_pad.writetobuffer(buf) 
3698          try: self.__field_type 
3699          except: 
3700              self.__field_type=UINT(**{'sizeinbytes': 1, 'default': 9}) 
3701          self.__field_type.writetobuffer(buf) 
3702          self._bufferendoffset=buf.getcurrentoffset() 
3703          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3704   
3705   
3706 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3707          'Reads this packet from the supplied buffer' 
3708          self._bufferstartoffset=buf.getcurrentoffset() 
3709          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3710          self.__field_contactp=UINT(**{'sizeinbytes': 2}) 
3711          self.__field_contactp.readfrombuffer(buf) 
3712          self.__field_url_len=UINT(**{'sizeinbytes': 1}) 
3713          self.__field_url_len.readfrombuffer(buf) 
3714          self.__field_url=USTRING(**{'sizeinbytes': 96, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
3715          self.__field_url.readfrombuffer(buf) 
3716          self.__field_pad=UNKNOWN(**{'sizeinbytes': 1}) 
3717          self.__field_pad.readfrombuffer(buf) 
3718          self.__field_type=UINT(**{'sizeinbytes': 1, 'default': 9}) 
3719          self.__field_type.readfrombuffer(buf) 
3720          self._bufferendoffset=buf.getcurrentoffset() 
3721   
3722   
3723 -    def __getfield_contactp(self): 
3724          return self.__field_contactp.getvalue() 
3725   
3726 -    def __setfield_contactp(self, value): 
3727          if isinstance(value,UINT): 
3728              self.__field_contactp=value 
3729          else: 
3730              self.__field_contactp=UINT(value,**{'sizeinbytes': 2}) 
3731   
3732 -    def __delfield_contactp(self): del self.__field_contactp 
3733   
3734      contactp=property(__getfield_contactp, __setfield_contactp, __delfield_contactp, "Pointer to contact number belongs") 
3735   
3736 -    def __getfield_url_len(self): 
3737          return self.__field_url_len.getvalue() 
3738   
3739 -    def __setfield_url_len(self, value): 
3740          if isinstance(value,UINT): 
3741              self.__field_url_len=value 
3742          else: 
3743              self.__field_url_len=UINT(value,**{'sizeinbytes': 1}) 
3744   
3745 -    def __delfield_url_len(self): del self.__field_url_len 
3746   
3747      url_len=property(__getfield_url_len, __setfield_url_len, __delfield_url_len, None) 
3748   
3749 -    def __getfield_url(self): 
3750          try: self.__field_url 
3751          except: 
3752              self.__field_url=USTRING(**{'sizeinbytes': 96, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
3753          return self.__field_url.getvalue() 
3754   
3755 -    def __setfield_url(self, value): 
3756          if isinstance(value,USTRING): 
3757              self.__field_url=value 
3758          else: 
3759              self.__field_url=USTRING(value,**{'sizeinbytes': 96, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
3760   
3761 -    def __delfield_url(self): del self.__field_url 
3762   
3763      url=property(__getfield_url, __setfield_url, __delfield_url, None) 
3764   
3765 -    def __getfield_pad(self): 
3766          try: self.__field_pad 
3767          except: 
3768              self.__field_pad=UNKNOWN(**{'sizeinbytes': 1}) 
3769          return self.__field_pad.getvalue() 
3770   
3771 -    def __setfield_pad(self, value): 
3772          if isinstance(value,UNKNOWN): 
3773              self.__field_pad=value 
3774          else: 
3775              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 1}) 
3776   
3777 -    def __delfield_pad(self): del self.__field_pad 
3778   
3779      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
3780   
3781 -    def __getfield_type(self): 
3782          try: self.__field_type 
3783          except: 
3784              self.__field_type=UINT(**{'sizeinbytes': 1, 'default': 9}) 
3785          return self.__field_type.getvalue() 
3786   
3787 -    def __setfield_type(self, value): 
3788          if isinstance(value,UINT): 
3789              self.__field_type=value 
3790          else: 
3791              self.__field_type=UINT(value,**{'sizeinbytes': 1, 'default': 9}) 
3792   
3793 -    def __delfield_type(self): del self.__field_type 
3794   
3795      type=property(__getfield_type, __setfield_type, __delfield_type, "Always 9 for World Icon") 
3796   
3797 -    def iscontainer(self): 
3798          return True 
3799   
3800 -    def containerelements(self): 
3801          yield ('contactp', self.__field_contactp, "Pointer to contact number belongs") 
3802          yield ('url_len', self.__field_url_len, None) 
3803          yield ('url', self.__field_url, None) 
3804          yield ('pad', self.__field_pad, None) 
3805          yield ('type', self.__field_type, "Always 9 for World Icon") 
3806   
3807   
3808   
3809   
3810 -class urlresponse(BaseProtogenClass): 
3811      __fields=['header', 'slot', 'entry', 'pad'] 
3812   
3813 -    def __init__(self, *args, **kwargs): 
3814          dict={} 
3815          # What was supplied to this function 
3816          dict.update(kwargs) 
3817          # Parent constructor 
3818          super(urlresponse,self).__init__(**dict) 
3819          if self.__class__ is urlresponse: 
3820              self._update(args,dict) 
3821   
3822   
3823 -    def getfields(self): 
3824          return self.__fields 
3825   
3826   
3827 -    def _update(self, args, kwargs): 
3828          super(urlresponse,self)._update(args,kwargs) 
3829          keys=kwargs.keys() 
3830          for key in keys: 
3831              if key in self.__fields: 
3832                  setattr(self, key, kwargs[key]) 
3833                  del kwargs[key] 
3834          # Were any unrecognized kwargs passed in? 
3835          if __debug__: 
3836              self._complainaboutunusedargs(urlresponse,kwargs) 
3837          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
3838          # Make all P fields that haven't already been constructed 
3839   
3840   
3841 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3842          'Writes this packet to the supplied buffer' 
3843          self._bufferstartoffset=buf.getcurrentoffset() 
3844          self.__field_header.writetobuffer(buf) 
3845          self.__field_slot.writetobuffer(buf) 
3846          self.__field_entry.writetobuffer(buf) 
3847          self.__field_pad.writetobuffer(buf) 
3848          self._bufferendoffset=buf.getcurrentoffset() 
3849          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3850   
3851   
3852 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3853          'Reads this packet from the supplied buffer' 
3854          self._bufferstartoffset=buf.getcurrentoffset() 
3855          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3856          self.__field_header=sanyoheader() 
3857          self.__field_header.readfrombuffer(buf) 
3858          self.__field_slot=UINT(**{'sizeinbytes': 2}) 
3859          self.__field_slot.readfrombuffer(buf) 
3860          self.__field_entry=urlentry() 
3861          self.__field_entry.readfrombuffer(buf) 
3862          self.__field_pad=UNKNOWN() 
3863          self.__field_pad.readfrombuffer(buf) 
3864          self._bufferendoffset=buf.getcurrentoffset() 
3865   
3866   
3867 -    def __getfield_header(self): 
3868          return self.__field_header.getvalue() 
3869   
3870 -    def __setfield_header(self, value): 
3871          if isinstance(value,sanyoheader): 
3872              self.__field_header=value 
3873          else: 
3874              self.__field_header=sanyoheader(value,) 
3875   
3876 -    def __delfield_header(self): del self.__field_header 
3877   
3878      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
3879   
3880 -    def __getfield_slot(self): 
3881          return self.__field_slot.getvalue() 
3882   
3883 -    def __setfield_slot(self, value): 
3884          if isinstance(value,UINT): 
3885              self.__field_slot=value 
3886          else: 
3887              self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 
3888   
3889 -    def __delfield_slot(self): del self.__field_slot 
3890   
3891      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
3892   
3893 -    def __getfield_entry(self): 
3894          return self.__field_entry.getvalue() 
3895   
3896 -    def __setfield_entry(self, value): 
3897          if isinstance(value,urlentry): 
3898              self.__field_entry=value 
3899          else: 
3900              self.__field_entry=urlentry(value,) 
3901   
3902 -    def __delfield_entry(self): del self.__field_entry 
3903   
3904      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
3905   
3906 -    def __getfield_pad(self): 
3907          return self.__field_pad.getvalue() 
3908   
3909 -    def __setfield_pad(self, value): 
3910          if isinstance(value,UNKNOWN): 
3911              self.__field_pad=value 
3912          else: 
3913              self.__field_pad=UNKNOWN(value,) 
3914   
3915 -    def __delfield_pad(self): del self.__field_pad 
3916   
3917      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
3918   
3919 -    def iscontainer(self): 
3920          return True 
3921   
3922 -    def containerelements(self): 
3923          yield ('header', self.__field_header, None) 
3924          yield ('slot', self.__field_slot, None) 
3925          yield ('entry', self.__field_entry, None) 
3926          yield ('pad', self.__field_pad, None) 
3927   
3928   
3929   
3930   
3931 -class urlupdaterequest(BaseProtogenClass): 
3932      __fields=['header', 'slot', 'entry'] 
3933   
3934 -    def __init__(self, *args, **kwargs): 
3935          dict={} 
3936          # What was supplied to this function 
3937          dict.update(kwargs) 
3938          # Parent constructor 
3939          super(urlupdaterequest,self).__init__(**dict) 
3940          if self.__class__ is urlupdaterequest: 
3941              self._update(args,dict) 
3942   
3943   
3944 -    def getfields(self): 
3945          return self.__fields 
3946   
3947   
3948 -    def _update(self, args, kwargs): 
3949          super(urlupdaterequest,self)._update(args,kwargs) 
3950          keys=kwargs.keys() 
3951          for key in keys: 
3952              if key in self.__fields: 
3953                  setattr(self, key, kwargs[key]) 
3954                  del kwargs[key] 
3955          # Were any unrecognized kwargs passed in? 
3956          if __debug__: 
3957              self._complainaboutunusedargs(urlupdaterequest,kwargs) 
3958          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
3959          # Make all P fields that haven't already been constructed 
3960   
3961   
3962 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3963          'Writes this packet to the supplied buffer' 
3964          self._bufferstartoffset=buf.getcurrentoffset() 
3965          try: self.__field_header 
3966          except: 
3967              self.__field_header=sanyowriteheader(**{'packettype': 0x16,                   'command': 0x98}) 
3968          self.__field_header.writetobuffer(buf) 
3969          self.__field_slot.writetobuffer(buf) 
3970          try: self.__field_entry 
3971          except: 
3972              self.__field_entry=urlentry() 
3973          self.__field_entry.writetobuffer(buf) 
3974          self._bufferendoffset=buf.getcurrentoffset() 
3975          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3976   
3977   
3978 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3979          'Reads this packet from the supplied buffer' 
3980          self._bufferstartoffset=buf.getcurrentoffset() 
3981          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3982          self.__field_header=sanyowriteheader(**{'packettype': 0x16,                   'command': 0x98}) 
3983          self.__field_header.readfrombuffer(buf) 
3984          self.__field_slot=UINT(**{'sizeinbytes': 2}) 
3985          self.__field_slot.readfrombuffer(buf) 
3986          self.__field_entry=urlentry() 
3987          self.__field_entry.readfrombuffer(buf) 
3988          self._bufferendoffset=buf.getcurrentoffset() 
3989   
3990   
3991 -    def __getfield_header(self): 
3992          try: self.__field_header 
3993          except: 
3994              self.__field_header=sanyowriteheader(**{'packettype': 0x16,                   'command': 0x98}) 
3995          return self.__field_header.getvalue() 
3996   
3997 -    def __setfield_header(self, value): 
3998          if isinstance(value,sanyowriteheader): 
3999              self.__field_header=value 
4000          else: 
4001              self.__field_header=sanyowriteheader(value,**{'packettype': 0x16,                   'command': 0x98}) 
4002   
4003 -    def __delfield_header(self): del self.__field_header 
4004   
4005      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
4006   
4007 -    def __getfield_slot(self): 
4008          return self.__field_slot.getvalue() 
4009   
4010 -    def __setfield_slot(self, value): 
4011          if isinstance(value,UINT): 
4012              self.__field_slot=value 
4013          else: 
4014              self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 
4015   
4016 -    def __delfield_slot(self): del self.__field_slot 
4017   
4018      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
4019   
4020 -    def __getfield_entry(self): 
4021          try: self.__field_entry 
4022          except: 
4023              self.__field_entry=urlentry() 
4024          return self.__field_entry.getvalue() 
4025   
4026 -    def __setfield_entry(self, value): 
4027          if isinstance(value,urlentry): 
4028              self.__field_entry=value 
4029          else: 
4030              self.__field_entry=urlentry(value,) 
4031   
4032 -    def __delfield_entry(self): del self.__field_entry 
4033   
4034      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
4035   
4036 -    def iscontainer(self): 
4037          return True 
4038   
4039 -    def containerelements(self): 
4040          yield ('header', self.__field_header, None) 
4041          yield ('slot', self.__field_slot, None) 
4042          yield ('entry', self.__field_entry, None) 
4043   
4044   
4045   
4046   
4047 -class addressrequest(BaseProtogenClass): 
4048      __fields=['header', 'slot'] 
4049   
4050 -    def __init__(self, *args, **kwargs): 
4051          dict={} 
4052          # What was supplied to this function 
4053          dict.update(kwargs) 
4054          # Parent constructor 
4055          super(addressrequest,self).__init__(**dict) 
4056          if self.__class__ is addressrequest: 
4057              self._update(args,dict) 
4058   
4059   
4060 -    def getfields(self): 
4061          return self.__fields 
4062   
4063   
4064 -    def _update(self, args, kwargs): 
4065          super(addressrequest,self)._update(args,kwargs) 
4066          keys=kwargs.keys() 
4067          for key in keys: 
4068              if key in self.__fields: 
4069                  setattr(self, key, kwargs[key]) 
4070                  del kwargs[key] 
4071          # Were any unrecognized kwargs passed in? 
4072          if __debug__: 
4073              self._complainaboutunusedargs(addressrequest,kwargs) 
4074          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
4075          # Make all P fields that haven't already been constructed 
4076   
4077   
4078 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
4079          'Writes this packet to the supplied buffer' 
4080          self._bufferstartoffset=buf.getcurrentoffset() 
4081          try: self.__field_header 
4082          except: 
4083              self.__field_header=sanyoheader(**{'packettype': 0x16,                   'command': 0x9b}) 
4084          self.__field_header.writetobuffer(buf) 
4085          self.__field_slot.writetobuffer(buf) 
4086          self._bufferendoffset=buf.getcurrentoffset() 
4087          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
4088   
4089   
4090 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
4091          'Reads this packet from the supplied buffer' 
4092          self._bufferstartoffset=buf.getcurrentoffset() 
4093          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
4094          self.__field_header=sanyoheader(**{'packettype': 0x16,                   'command': 0x9b}) 
4095          self.__field_header.readfrombuffer(buf) 
4096          self.__field_slot=UINT(**{'sizeinbytes': 2}) 
4097          self.__field_slot.readfrombuffer(buf) 
4098          self._bufferendoffset=buf.getcurrentoffset() 
4099   
4100   
4101 -    def __getfield_header(self): 
4102          try: self.__field_header 
4103          except: 
4104              self.__field_header=sanyoheader(**{'packettype': 0x16,                   'command': 0x9b}) 
4105          return self.__field_header.getvalue() 
4106   
4107 -    def __setfield_header(self, value): 
4108          if isinstance(value,sanyoheader): 
4109              self.__field_header=value 
4110          else: 
4111              self.__field_header=sanyoheader(value,**{'packettype': 0x16,                   'command': 0x9b}) 
4112   
4113 -    def __delfield_header(self): del self.__field_header 
4114   
4115      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
4116   
4117 -    def __getfield_slot(self): 
4118          return self.__field_slot.getvalue() 
4119   
4120 -    def __setfield_slot(self, value): 
4121          if isinstance(value,UINT): 
4122              self.__field_slot=value 
4123          else: 
4124              self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 
4125   
4126 -    def __delfield_slot(self): del self.__field_slot 
4127   
4128      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
4129   
4130 -    def iscontainer(self): 
4131          return True 
4132   
4133 -    def containerelements(self): 
4134          yield ('header', self.__field_header, None) 
4135          yield ('slot', self.__field_slot, None) 
4136   
4137   
4138   
4139   
4140 -class addressentry(BaseProtogenClass): 
4141      __fields=['contactp', 'address_len', 'address'] 
4142   
4143 -    def __init__(self, *args, **kwargs): 
4144          dict={} 
4145          # What was supplied to this function 
4146          dict.update(kwargs) 
4147          # Parent constructor 
4148          super(addressentry,self).__init__(**dict) 
4149          if self.__class__ is addressentry: 
4150              self._update(args,dict) 
4151   
4152   
4153 -    def getfields(self): 
4154          return self.__fields 
4155   
4156   
4157 -    def _update(self, args, kwargs): 
4158          super(addressentry,self)._update(args,kwargs) 
4159          keys=kwargs.keys() 
4160          for key in keys: 
4161              if key in self.__fields: 
4162                  setattr(self, key, kwargs[key]) 
4163                  del kwargs[key] 
4164          # Were any unrecognized kwargs passed in? 
4165          if __debug__: 
4166              self._complainaboutunusedargs(addressentry,kwargs) 
4167          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
4168          # Make all P fields that haven't already been constructed 
4169   
4170   
4171 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
4172          'Writes this packet to the supplied buffer' 
4173          self._bufferstartoffset=buf.getcurrentoffset() 
4174          self.__field_contactp.writetobuffer(buf) 
4175          self.__field_address_len.writetobuffer(buf) 
4176          try: self.__field_address 
4177          except: 
4178              self.__field_address=USTRING(**{'sizeinbytes': 256, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
4179          self.__field_address.writetobuffer(buf) 
4180          self._bufferendoffset=buf.getcurrentoffset() 
4181          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
4182   
4183   
4184 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
4185          'Reads this packet from the supplied buffer' 
4186          self._bufferstartoffset=buf.getcurrentoffset() 
4187          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
4188          self.__field_contactp=UINT(**{'sizeinbytes': 2}) 
4189          self.__field_contactp.readfrombuffer(buf) 
4190          self.__field_address_len=UINT(**{'sizeinbytes': 2}) 
4191          self.__field_address_len.readfrombuffer(buf) 
4192          self.__field_address=USTRING(**{'sizeinbytes': 256, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
4193          self.__field_address.readfrombuffer(buf) 
4194          self._bufferendoffset=buf.getcurrentoffset() 
4195   
4196   
4197 -    def __getfield_contactp(self): 
4198          return self.__field_contactp.getvalue() 
4199   
4200 -    def __setfield_contactp(self, value): 
4201          if isinstance(value,UINT): 
4202              self.__field_contactp=value 
4203          else: 
4204              self.__field_contactp=UINT(value,**{'sizeinbytes': 2}) 
4205   
4206 -    def __delfield_contactp(self): del self.__field_contactp 
4207   
4208      contactp=property(__getfield_contactp, __setfield_contactp, __delfield_contactp, "Pointer to contact number belongs") 
4209   
4210 -    def __getfield_address_len(self): 
4211          return self.__field_address_len.getvalue() 
4212   
4213 -    def __setfield_address_len(self, value): 
4214          if isinstance(value,UINT): 
4215              self.__field_address_len=value 
4216          else: 
4217              self.__field_address_len=UINT(value,**{'sizeinbytes': 2}) 
4218   
4219 -    def __delfield_address_len(self): del self.__field_address_len 
4220   
4221      address_len=property(__getfield_address_len, __setfield_address_len, __delfield_address_len, None) 
4222   
4223 -    def __getfield_address(self): 
4224          try: self.__field_address 
4225          except: 
4226              self.__field_address=USTRING(**{'sizeinbytes': 256, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
4227          return self.__field_address.getvalue() 
4228   
4229 -    def __setfield_address(self, value): 
4230          if isinstance(value,USTRING): 
4231              self.__field_address=value 
4232          else: 
4233              self.__field_address=USTRING(value,**{'sizeinbytes': 256, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
4234   
4235 -    def __delfield_address(self): del self.__field_address 
4236   
4237      address=property(__getfield_address, __setfield_address, __delfield_address, None) 
4238   
4239 -    def iscontainer(self): 
4240          return True 
4241   
4242 -    def containerelements(self): 
4243          yield ('contactp', self.__field_contactp, "Pointer to contact number belongs") 
4244          yield ('address_len', self.__field_address_len, None) 
4245          yield ('address', self.__field_address, None) 
4246   
4247   
4248   
4249   
4250 -class addressresponse(BaseProtogenClass): 
4251      __fields=['header', 'slot', 'entry', 'pad'] 
4252   
4253 -    def __init__(self, *args, **kwargs): 
4254          dict={} 
4255          # What was supplied to this function 
4256          dict.update(kwargs) 
4257          # Parent constructor 
4258          super(addressresponse,self).__init__(**dict) 
4259          if self.__class__ is addressresponse: 
4260              self._update(args,dict) 
4261   
4262   
4263 -    def getfields(self): 
4264          return self.__fields 
4265   
4266   
4267 -    def _update(self, args, kwargs): 
4268          super(addressresponse,self)._update(args,kwargs) 
4269          keys=kwargs.keys() 
4270          for key in keys: 
4271              if key in self.__fields: 
4272                  setattr(self, key, kwargs[key]) 
4273                  del kwargs[key] 
4274          # Were any unrecognized kwargs passed in? 
4275          if __debug__: 
4276              self._complainaboutunusedargs(addressresponse,kwargs) 
4277          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
4278          # Make all P fields that haven't already been constructed 
4279   
4280   
4281 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
4282          'Writes this packet to the supplied buffer' 
4283          self._bufferstartoffset=buf.getcurrentoffset() 
4284          self.__field_header.writetobuffer(buf) 
4285          self.__field_slot.writetobuffer(buf) 
4286          self.__field_entry.writetobuffer(buf) 
4287          self.__field_pad.writetobuffer(buf) 
4288          self._bufferendoffset=buf.getcurrentoffset() 
4289          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
4290   
4291   
4292 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
4293          'Reads this packet from the supplied buffer' 
4294          self._bufferstartoffset=buf.getcurrentoffset() 
4295          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
4296          self.__field_header=sanyoheader() 
4297          self.__field_header.readfrombuffer(buf) 
4298          self.__field_slot=UINT(**{'sizeinbytes': 2}) 
4299          self.__field_slot.readfrombuffer(buf) 
4300          self.__field_entry=addressentry() 
4301          self.__field_entry.readfrombuffer(buf) 
4302          self.__field_pad=UNKNOWN() 
4303          self.__field_pad.readfrombuffer(buf) 
4304          self._bufferendoffset=buf.getcurrentoffset() 
4305   
4306   
4307 -    def __getfield_header(self): 
4308          return self.__field_header.getvalue() 
4309   
4310 -    def __setfield_header(self, value): 
4311          if isinstance(value,sanyoheader): 
4312              self.__field_header=value 
4313          else: 
4314              self.__field_header=sanyoheader(value,) 
4315   
4316 -    def __delfield_header(self): del self.__field_header 
4317   
4318      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
4319   
4320 -    def __getfield_slot(self): 
4321          return self.__field_slot.getvalue() 
4322   
4323 -    def __setfield_slot(self, value): 
4324          if isinstance(value,UINT): 
4325              self.__field_slot=value 
4326          else: 
4327              self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 
4328   
4329 -    def __delfield_slot(self): del self.__field_slot 
4330   
4331      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
4332   
4333 -    def __getfield_entry(self): 
4334          return self.__field_entry.getvalue() 
4335   
4336 -    def __setfield_entry(self, value): 
4337          if isinstance(value,addressentry): 
4338              self.__field_entry=value 
4339          else: 
4340              self.__field_entry=addressentry(value,) 
4341   
4342 -    def __delfield_entry(self): del self.__field_entry 
4343   
4344      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
4345   
4346 -    def __getfield_pad(self): 
4347          return self.__field_pad.getvalue() 
4348   
4349 -    def __setfield_pad(self, value): 
4350          if isinstance(value,UNKNOWN): 
4351              self.__field_pad=value 
4352          else: 
4353              self.__field_pad=UNKNOWN(value,) 
4354   
4355 -    def __delfield_pad(self): del self.__field_pad 
4356   
4357      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
4358   
4359 -    def iscontainer(self): 
4360          return True 
4361   
4362 -    def containerelements(self): 
4363          yield ('header', self.__field_header, None) 
4364          yield ('slot', self.__field_slot, None) 
4365          yield ('entry', self.__field_entry, None) 
4366          yield ('pad', self.__field_pad, None) 
4367   
4368   
4369   
4370   
4371 -class addressupdaterequest(BaseProtogenClass): 
4372      __fields=['header', 'slot', 'entry'] 
4373   
4374 -    def __init__(self, *args, **kwargs): 
4375          dict={} 
4376          # What was supplied to this function 
4377          dict.update(kwargs) 
4378          # Parent constructor 
4379          super(addressupdaterequest,self).__init__(**dict) 
4380          if self.__class__ is addressupdaterequest: 
4381              self._update(args,dict) 
4382   
4383   
4384 -    def getfields(self): 
4385          return self.__fields 
4386   
4387   
4388 -    def _update(self, args, kwargs): 
4389          super(addressupdaterequest,self)._update(args,kwargs) 
4390          keys=kwargs.keys() 
4391          for key in keys: 
4392              if key in self.__fields: 
4393                  setattr(self, key, kwargs[key]) 
4394                  del kwargs[key] 
4395          # Were any unrecognized kwargs passed in? 
4396          if __debug__: 
4397              self._complainaboutunusedargs(addressupdaterequest,kwargs) 
4398          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
4399          # Make all P fields that haven't already been constructed 
4400   
4401   
4402 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
4403          'Writes this packet to the supplied buffer' 
4404          self._bufferstartoffset=buf.getcurrentoffset() 
4405          try: self.__field_header 
4406          except: 
4407              self.__field_header=sanyowriteheader(**{'packettype': 0x16,                   'command': 0x9b}) 
4408          self.__field_header.writetobuffer(buf) 
4409          self.__field_slot.writetobuffer(buf) 
4410          try: self.__field_entry 
4411          except: 
4412              self.__field_entry=addressentry() 
4413          self.__field_entry.writetobuffer(buf) 
4414          self._bufferendoffset=buf.getcurrentoffset() 
4415          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
4416   
4417   
4418 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
4419          'Reads this packet from the supplied buffer' 
4420          self._bufferstartoffset=buf.getcurrentoffset() 
4421          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
4422          self.__field_header=sanyowriteheader(**{'packettype': 0x16,                   'command': 0x9b}) 
4423          self.__field_header.readfrombuffer(buf) 
4424          self.__field_slot=UINT(**{'sizeinbytes': 2}) 
4425          self.__field_slot.readfrombuffer(buf) 
4426          self.__field_entry=addressentry() 
4427          self.__field_entry.readfrombuffer(buf) 
4428          self._bufferendoffset=buf.getcurrentoffset() 
4429   
4430   
4431 -    def __getfield_header(self): 
4432          try: self.__field_header 
4433          except: 
4434              self.__field_header=sanyowriteheader(**{'packettype': 0x16,                   'command': 0x9b}) 
4435          return self.__field_header.getvalue() 
4436   
4437 -    def __setfield_header(self, value): 
4438          if isinstance(value,sanyowriteheader): 
4439              self.__field_header=value 
4440          else: 
4441              self.__field_header=sanyowriteheader(value,**{'packettype': 0x16,                   'command': 0x9b}) 
4442   
4443 -    def __delfield_header(self): del self.__field_header 
4444   
4445      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
4446   
4447 -    def __getfield_slot(self): 
4448          return self.__field_slot.getvalue() 
4449   
4450 -    def __setfield_slot(self, value): 
4451          if isinstance(value,UINT): 
4452              self.__field_slot=value 
4453          else: 
4454              self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 
4455   
4456 -    def __delfield_slot(self): del self.__field_slot 
4457   
4458      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
4459   
4460 -    def __getfield_entry(self): 
4461          try: self.__field_entry 
4462          except: 
4463              self.__field_entry=addressentry() 
4464          return self.__field_entry.getvalue() 
4465   
4466 -    def __setfield_entry(self, value): 
4467          if isinstance(value,addressentry): 
4468              self.__field_entry=value 
4469          else: 
4470              self.__field_entry=addressentry(value,) 
4471   
4472 -    def __delfield_entry(self): del self.__field_entry 
4473   
4474      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
4475   
4476 -    def iscontainer(self): 
4477          return True 
4478   
4479 -    def containerelements(self): 
4480          yield ('header', self.__field_header, None) 
4481          yield ('slot', self.__field_slot, None) 
4482          yield ('entry', self.__field_entry, None) 
4483   
4484   
4485   
4486   
4487 -class memorequest(BaseProtogenClass): 
4488      __fields=['header', 'slot'] 
4489   
4490 -    def __init__(self, *args, **kwargs): 
4491          dict={} 
4492          # What was supplied to this function 
4493          dict.update(kwargs) 
4494          # Parent constructor 
4495          super(memorequest,self).__init__(**dict) 
4496          if self.__class__ is memorequest: 
4497              self._update(args,dict) 
4498   
4499   
4500 -    def getfields(self): 
4501          return self.__fields 
4502   
4503   
4504 -    def _update(self, args, kwargs): 
4505          super(memorequest,self)._update(args,kwargs) 
4506          keys=kwargs.keys() 
4507          for key in keys: 
4508              if key in self.__fields: 
4509                  setattr(self, key, kwargs[key]) 
4510                  del kwargs[key] 
4511          # Were any unrecognized kwargs passed in? 
4512          if __debug__: 
4513              self._complainaboutunusedargs(memorequest,kwargs) 
4514          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
4515          # Make all P fields that haven't already been constructed 
4516   
4517   
4518 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
4519          'Writes this packet to the supplied buffer' 
4520          self._bufferstartoffset=buf.getcurrentoffset() 
4521          try: self.__field_header 
4522          except: 
4523              self.__field_header=sanyoheader(**{'packettype': 0x16,                   'command': 0x9e}) 
4524          self.__field_header.writetobuffer(buf) 
4525          self.__field_slot.writetobuffer(buf) 
4526          self._bufferendoffset=buf.getcurrentoffset() 
4527          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
4528   
4529   
4530 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
4531          'Reads this packet from the supplied buffer' 
4532          self._bufferstartoffset=buf.getcurrentoffset() 
4533          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
4534          self.__field_header=sanyoheader(**{'packettype': 0x16,                   'command': 0x9e}) 
4535          self.__field_header.readfrombuffer(buf) 
4536          self.__field_slot=UINT(**{'sizeinbytes': 2}) 
4537          self.__field_slot.readfrombuffer(buf) 
4538          self._bufferendoffset=buf.getcurrentoffset() 
4539   
4540   
4541 -    def __getfield_header(self): 
4542          try: self.__field_header 
4543          except: 
4544              self.__field_header=sanyoheader(**{'packettype': 0x16,                   'command': 0x9e}) 
4545          return self.__field_header.getvalue() 
4546   
4547 -    def __setfield_header(self, value): 
4548          if isinstance(value,sanyoheader): 
4549              self.__field_header=value 
4550          else: 
4551              self.__field_header=sanyoheader(value,**{'packettype': 0x16,                   'command': 0x9e}) 
4552   
4553 -    def __delfield_header(self): del self.__field_header 
4554   
4555      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
4556   
4557 -    def __getfield_slot(self): 
4558          return self.__field_slot.getvalue() 
4559   
4560 -    def __setfield_slot(self, value): 
4561          if isinstance(value,UINT): 
4562              self.__field_slot=value 
4563          else: 
4564              self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 
4565   
4566 -    def __delfield_slot(self): del self.__field_slot 
4567   
4568      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
4569   
4570 -    def iscontainer(self): 
4571          return True 
4572   
4573 -    def containerelements(self): 
4574          yield ('header', self.__field_header, None) 
4575          yield ('slot', self.__field_slot, None) 
4576   
4577   
4578   
4579   
4580 -class memoentry(BaseProtogenClass): 
4581      __fields=['contactp', 'memo_len', 'memo'] 
4582   
4583 -    def __init__(self, *args, **kwargs): 
4584          dict={} 
4585          # What was supplied to this function 
4586          dict.update(kwargs) 
4587          # Parent constructor 
4588          super(memoentry,self).__init__(**dict) 
4589          if self.__class__ is memoentry: 
4590              self._update(args,dict) 
4591   
4592   
4593 -    def getfields(self): 
4594          return self.__fields 
4595   
4596   
4597 -    def _update(self, args, kwargs): 
4598          super(memoentry,self)._update(args,kwargs) 
4599          keys=kwargs.keys() 
4600          for key in keys: 
4601              if key in self.__fields: 
4602                  setattr(self, key, kwargs[key]) 
4603                  del kwargs[key] 
4604          # Were any unrecognized kwargs passed in? 
4605          if __debug__: 
4606              self._complainaboutunusedargs(memoentry,kwargs) 
4607          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
4608          # Make all P fields that haven't already been constructed 
4609   
4610   
4611 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
4612          'Writes this packet to the supplied buffer' 
4613          self._bufferstartoffset=buf.getcurrentoffset() 
4614          self.__field_contactp.writetobuffer(buf) 
4615          self.__field_memo_len.writetobuffer(buf) 
4616          try: self.__field_memo 
4617          except: 
4618              self.__field_memo=USTRING(**{'sizeinbytes': 256, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
4619          self.__field_memo.writetobuffer(buf) 
4620          self._bufferendoffset=buf.getcurrentoffset() 
4621          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
4622   
4623   
4624 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
4625          'Reads this packet from the supplied buffer' 
4626          self._bufferstartoffset=buf.getcurrentoffset() 
4627          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
4628          self.__field_contactp=UINT(**{'sizeinbytes': 2}) 
4629          self.__field_contactp.readfrombuffer(buf) 
4630          self.__field_memo_len=UINT(**{'sizeinbytes': 2}) 
4631          self.__field_memo_len.readfrombuffer(buf) 
4632          self.__field_memo=USTRING(**{'sizeinbytes': 256, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
4633          self.__field_memo.readfrombuffer(buf) 
4634          self._bufferendoffset=buf.getcurrentoffset() 
4635   
4636   
4637 -    def __getfield_contactp(self): 
4638          return self.__field_contactp.getvalue() 
4639   
4640 -    def __setfield_contactp(self, value): 
4641          if isinstance(value,UINT): 
4642              self.__field_contactp=value 
4643          else: 
4644              self.__field_contactp=UINT(value,**{'sizeinbytes': 2}) 
4645   
4646 -    def __delfield_contactp(self): del self.__field_contactp 
4647   
4648      contactp=property(__getfield_contactp, __setfield_contactp, __delfield_contactp, "Pointer to contact number belongs") 
4649   
4650 -    def __getfield_memo_len(self): 
4651          return self.__field_memo_len.getvalue() 
4652   
4653 -    def __setfield_memo_len(self, value): 
4654          if isinstance(value,UINT): 
4655              self.__field_memo_len=value 
4656          else: 
4657              self.__field_memo_len=UINT(value,**{'sizeinbytes': 2}) 
4658   
4659 -    def __delfield_memo_len(self): del self.__field_memo_len 
4660   
4661      memo_len=property(__getfield_memo_len, __setfield_memo_len, __delfield_memo_len, None) 
4662   
4663 -    def __getfield_memo(self): 
4664          try: self.__field_memo 
4665          except: 
4666              self.__field_memo=USTRING(**{'sizeinbytes': 256, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
4667          return self.__field_memo.getvalue() 
4668   
4669 -    def __setfield_memo(self, value): 
4670          if isinstance(value,USTRING): 
4671              self.__field_memo=value 
4672          else: 
4673              self.__field_memo=USTRING(value,**{'sizeinbytes': 256, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
4674   
4675 -    def __delfield_memo(self): del self.__field_memo 
4676   
4677      memo=property(__getfield_memo, __setfield_memo, __delfield_memo, None) 
4678   
4679 -    def iscontainer(self): 
4680          return True 
4681   
4682 -    def containerelements(self): 
4683          yield ('contactp', self.__field_contactp, "Pointer to contact number belongs") 
4684          yield ('memo_len', self.__field_memo_len, None) 
4685          yield ('memo', self.__field_memo, None) 
4686   
4687   
4688   
4689   
4690 -class memoresponse(BaseProtogenClass): 
4691      __fields=['header', 'slot', 'entry', 'pad'] 
4692   
4693 -    def __init__(self, *args, **kwargs): 
4694          dict={} 
4695          # What was supplied to this function 
4696          dict.update(kwargs) 
4697          # Parent constructor 
4698          super(memoresponse,self).__init__(**dict) 
4699          if self.__class__ is memoresponse: 
4700              self._update(args,dict) 
4701   
4702   
4703 -    def getfields(self): 
4704          return self.__fields 
4705   
4706   
4707 -    def _update(self, args, kwargs): 
4708          super(memoresponse,self)._update(args,kwargs) 
4709          keys=kwargs.keys() 
4710          for key in keys: 
4711              if key in self.__fields: 
4712                  setattr(self, key, kwargs[key]) 
4713                  del kwargs[key] 
4714          # Were any unrecognized kwargs passed in? 
4715          if __debug__: 
4716              self._complainaboutunusedargs(memoresponse,kwargs) 
4717          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
4718          # Make all P fields that haven't already been constructed 
4719   
4720   
4721 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
4722          'Writes this packet to the supplied buffer' 
4723          self._bufferstartoffset=buf.getcurrentoffset() 
4724          self.__field_header.writetobuffer(buf) 
4725          self.__field_slot.writetobuffer(buf) 
4726          self.__field_entry.writetobuffer(buf) 
4727          self.__field_pad.writetobuffer(buf) 
4728          self._bufferendoffset=buf.getcurrentoffset() 
4729          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
4730   
4731   
4732 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
4733          'Reads this packet from the supplied buffer' 
4734          self._bufferstartoffset=buf.getcurrentoffset() 
4735          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
4736          self.__field_header=sanyoheader() 
4737          self.__field_header.readfrombuffer(buf) 
4738          self.__field_slot=UINT(**{'sizeinbytes': 2}) 
4739          self.__field_slot.readfrombuffer(buf) 
4740          self.__field_entry=memoentry() 
4741          self.__field_entry.readfrombuffer(buf) 
4742          self.__field_pad=UNKNOWN() 
4743          self.__field_pad.readfrombuffer(buf) 
4744          self._bufferendoffset=buf.getcurrentoffset() 
4745   
4746   
4747 -    def __getfield_header(self): 
4748          return self.__field_header.getvalue() 
4749   
4750 -    def __setfield_header(self, value): 
4751          if isinstance(value,sanyoheader): 
4752              self.__field_header=value 
4753          else: 
4754              self.__field_header=sanyoheader(value,) 
4755   
4756 -    def __delfield_header(self): del self.__field_header 
4757   
4758      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
4759   
4760 -    def __getfield_slot(self): 
4761          return self.__field_slot.getvalue() 
4762   
4763 -    def __setfield_slot(self, value): 
4764          if isinstance(value,UINT): 
4765              self.__field_slot=value 
4766          else: 
4767              self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 
4768   
4769 -    def __delfield_slot(self): del self.__field_slot 
4770   
4771      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
4772   
4773 -    def __getfield_entry(self): 
4774          return self.__field_entry.getvalue() 
4775   
4776 -    def __setfield_entry(self, value): 
4777          if isinstance(value,memoentry): 
4778              self.__field_entry=value 
4779          else: 
4780              self.__field_entry=memoentry(value,) 
4781   
4782 -    def __delfield_entry(self): del self.__field_entry 
4783   
4784      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
4785   
4786 -    def __getfield_pad(self): 
4787          return self.__field_pad.getvalue() 
4788   
4789 -    def __setfield_pad(self, value): 
4790          if isinstance(value,UNKNOWN): 
4791              self.__field_pad=value 
4792          else: 
4793              self.__field_pad=UNKNOWN(value,) 
4794   
4795 -    def __delfield_pad(self): del self.__field_pad 
4796   
4797      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
4798   
4799 -    def iscontainer(self): 
4800          return True 
4801   
4802 -    def containerelements(self): 
4803          yield ('header', self.__field_header, None) 
4804          yield ('slot', self.__field_slot, None) 
4805          yield ('entry', self.__field_entry, None) 
4806          yield ('pad', self.__field_pad, None) 
4807   
4808   
4809   
4810   
4811 -class memoupdaterequest(BaseProtogenClass): 
4812      __fields=['header', 'slot', 'entry'] 
4813   
4814 -    def __init__(self, *args, **kwargs): 
4815          dict={} 
4816          # What was supplied to this function 
4817          dict.update(kwargs) 
4818          # Parent constructor 
4819          super(memoupdaterequest,self).__init__(**dict) 
4820          if self.__class__ is memoupdaterequest: 
4821              self._update(args,dict) 
4822   
4823   
4824 -    def getfields(self): 
4825          return self.__fields 
4826   
4827   
4828 -    def _update(self, args, kwargs): 
4829          super(memoupdaterequest,self)._update(args,kwargs) 
4830          keys=kwargs.keys() 
4831          for key in keys: 
4832              if key in self.__fields: 
4833                  setattr(self, key, kwargs[key]) 
4834                  del kwargs[key] 
4835          # Were any unrecognized kwargs passed in? 
4836          if __debug__: 
4837              self._complainaboutunusedargs(memoupdaterequest,kwargs) 
4838          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
4839          # Make all P fields that haven't already been constructed 
4840   
4841   
4842 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
4843          'Writes this packet to the supplied buffer' 
4844          self._bufferstartoffset=buf.getcurrentoffset() 
4845          try: self.__field_header 
4846          except: 
4847              self.__field_header=sanyowriteheader(**{'packettype': 0x16,                   'command': 0x9e}) 
4848          self.__field_header.writetobuffer(buf) 
4849          self.__field_slot.writetobuffer(buf) 
4850          try: self.__field_entry 
4851          except: 
4852              self.__field_entry=memoentry() 
4853          self.__field_entry.writetobuffer(buf) 
4854          self._bufferendoffset=buf.getcurrentoffset() 
4855          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
4856   
4857   
4858 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
4859          'Reads this packet from the supplied buffer' 
4860          self._bufferstartoffset=buf.getcurrentoffset() 
4861          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
4862          self.__field_header=sanyowriteheader(**{'packettype': 0x16,                   'command': 0x9e}) 
4863          self.__field_header.readfrombuffer(buf) 
4864          self.__field_slot=UINT(**{'sizeinbytes': 2}) 
4865          self.__field_slot.readfrombuffer(buf) 
4866          self.__field_entry=memoentry() 
4867          self.__field_entry.readfrombuffer(buf) 
4868          self._bufferendoffset=buf.getcurrentoffset() 
4869   
4870   
4871 -    def __getfield_header(self): 
4872          try: self.__field_header 
4873          except: 
4874              self.__field_header=sanyowriteheader(**{'packettype': 0x16,                   'command': 0x9e}) 
4875          return self.__field_header.getvalue() 
4876   
4877 -    def __setfield_header(self, value): 
4878          if isinstance(value,sanyowriteheader): 
4879              self.__field_header=value 
4880          else: 
4881              self.__field_header=sanyowriteheader(value,**{'packettype': 0x16,                   'command': 0x9e}) 
4882   
4883 -    def __delfield_header(self): del self.__field_header 
4884   
4885      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
4886   
4887 -    def __getfield_slot(self): 
4888          return self.__field_slot.getvalue() 
4889   
4890 -    def __setfield_slot(self, value): 
4891          if isinstance(value,UINT): 
4892              self.__field_slot=value 
4893          else: 
4894              self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 
4895   
4896 -    def __delfield_slot(self): del self.__field_slot 
4897   
4898      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
4899   
4900 -    def __getfield_entry(self): 
4901          try: self.__field_entry 
4902          except: 
4903              self.__field_entry=memoentry() 
4904          return self.__field_entry.getvalue() 
4905   
4906 -    def __setfield_entry(self, value): 
4907          if isinstance(value,memoentry): 
4908              self.__field_entry=value 
4909          else: 
4910              self.__field_entry=memoentry(value,) 
4911   
4912 -    def __delfield_entry(self): del self.__field_entry 
4913   
4914      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
4915   
4916 -    def iscontainer(self): 
4917          return True 
4918   
4919 -    def containerelements(self): 
4920          yield ('header', self.__field_header, None) 
4921          yield ('slot', self.__field_slot, None) 
4922          yield ('entry', self.__field_entry, None) 
4923   
4924   
4925   
4926   
4927 -class emailrequest(BaseProtogenClass): 
4928      __fields=['header', 'slot'] 
4929   
4930 -    def __init__(self, *args, **kwargs): 
4931          dict={} 
4932          # What was supplied to this function 
4933          dict.update(kwargs) 
4934          # Parent constructor 
4935          super(emailrequest,self).__init__(**dict) 
4936          if self.__class__ is emailrequest: 
4937              self._update(args,dict) 
4938   
4939   
4940 -    def getfields(self): 
4941          return self.__fields 
4942   
4943   
4944 -    def _update(self, args, kwargs): 
4945          super(emailrequest,self)._update(args,kwargs) 
4946          keys=kwargs.keys() 
4947          for key in keys: 
4948              if key in self.__fields: 
4949                  setattr(self, key, kwargs[key]) 
4950                  del kwargs[key] 
4951          # Were any unrecognized kwargs passed in? 
4952          if __debug__: 
4953              self._complainaboutunusedargs(emailrequest,kwargs) 
4954          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
4955          # Make all P fields that haven't already been constructed 
4956   
4957   
4958 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
4959          'Writes this packet to the supplied buffer' 
4960          self._bufferstartoffset=buf.getcurrentoffset() 
4961          try: self.__field_header 
4962          except: 
4963              self.__field_header=sanyoheader(**{'packettype': 0x16,                   'command': 0x93}) 
4964          self.__field_header.writetobuffer(buf) 
4965          self.__field_slot.writetobuffer(buf) 
4966          self._bufferendoffset=buf.getcurrentoffset() 
4967          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
4968   
4969   
4970 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
4971          'Reads this packet from the supplied buffer' 
4972          self._bufferstartoffset=buf.getcurrentoffset() 
4973          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
4974          self.__field_header=sanyoheader(**{'packettype': 0x16,                   'command': 0x93}) 
4975          self.__field_header.readfrombuffer(buf) 
4976          self.__field_slot=UINT(**{'sizeinbytes': 2}) 
4977          self.__field_slot.readfrombuffer(buf) 
4978          self._bufferendoffset=buf.getcurrentoffset() 
4979   
4980   
4981 -    def __getfield_header(self): 
4982          try: self.__field_header 
4983          except: 
4984              self.__field_header=sanyoheader(**{'packettype': 0x16,                   'command': 0x93}) 
4985          return self.__field_header.getvalue() 
4986   
4987 -    def __setfield_header(self, value): 
4988          if isinstance(value,sanyoheader): 
4989              self.__field_header=value 
4990          else: 
4991              self.__field_header=sanyoheader(value,**{'packettype': 0x16,                   'command': 0x93}) 
4992   
4993 -    def __delfield_header(self): del self.__field_header 
4994   
4995      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
4996   
4997 -    def __getfield_slot(self): 
4998          return self.__field_slot.getvalue() 
4999   
5000 -    def __setfield_slot(self, value): 
5001          if isinstance(value,UINT): 
5002              self.__field_slot=value 
5003          else: 
5004              self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 
5005   
5006 -    def __delfield_slot(self): del self.__field_slot 
5007   
5008      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
5009   
5010 -    def iscontainer(self): 
5011          return True 
5012   
5013 -    def containerelements(self): 
5014          yield ('header', self.__field_header, None) 
5015          yield ('slot', self.__field_slot, None) 
5016   
5017   
5018   
5019   
5020 -class emailentry(BaseProtogenClass): 
5021      __fields=['contactp', 'email_len', 'email', 'pad', 'type'] 
5022   
5023 -    def __init__(self, *args, **kwargs): 
5024          dict={} 
5025          # What was supplied to this function 
5026          dict.update(kwargs) 
5027          # Parent constructor 
5028          super(emailentry,self).__init__(**dict) 
5029          if self.__class__ is emailentry: 
5030              self._update(args,dict) 
5031   
5032   
5033 -    def getfields(self): 
5034          return self.__fields 
5035   
5036   
5037 -    def _update(self, args, kwargs): 
5038          super(emailentry,self)._update(args,kwargs) 
5039          keys=kwargs.keys() 
5040          for key in keys: 
5041              if key in self.__fields: 
5042                  setattr(self, key, kwargs[key]) 
5043                  del kwargs[key] 
5044          # Were any unrecognized kwargs passed in? 
5045          if __debug__: 
5046              self._complainaboutunusedargs(emailentry,kwargs) 
5047          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
5048          # Make all P fields that haven't already been constructed 
5049   
5050   
5051 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
5052          'Writes this packet to the supplied buffer' 
5053          self._bufferstartoffset=buf.getcurrentoffset() 
5054          self.__field_contactp.writetobuffer(buf) 
5055          self.__field_email_len.writetobuffer(buf) 
5056          try: self.__field_email 
5057          except: 
5058              self.__field_email=USTRING(**{'sizeinbytes': 96, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
5059          self.__field_email.writetobuffer(buf) 
5060          try: self.__field_pad 
5061          except: 
5062              self.__field_pad=UNKNOWN(**{'sizeinbytes': 1}) 
5063          self.__field_pad.writetobuffer(buf) 
5064          try: self.__field_type 
5065          except: 
5066              self.__field_type=UINT(**{'sizeinbytes': 1, 'default': 8}) 
5067          self.__field_type.writetobuffer(buf) 
5068          self._bufferendoffset=buf.getcurrentoffset() 
5069          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
5070   
5071   
5072 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
5073          'Reads this packet from the supplied buffer' 
5074          self._bufferstartoffset=buf.getcurrentoffset() 
5075          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
5076          self.__field_contactp=UINT(**{'sizeinbytes': 2}) 
5077          self.__field_contactp.readfrombuffer(buf) 
5078          self.__field_email_len=UINT(**{'sizeinbytes': 1}) 
5079          self.__field_email_len.readfrombuffer(buf) 
5080          self.__field_email=USTRING(**{'sizeinbytes': 96, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
5081          self.__field_email.readfrombuffer(buf) 
5082          self.__field_pad=UNKNOWN(**{'sizeinbytes': 1}) 
5083          self.__field_pad.readfrombuffer(buf) 
5084          self.__field_type=UINT(**{'sizeinbytes': 1, 'default': 8}) 
5085          self.__field_type.readfrombuffer(buf) 
5086          self._bufferendoffset=buf.getcurrentoffset() 
5087   
5088   
5089 -    def __getfield_contactp(self): 
5090          return self.__field_contactp.getvalue() 
5091   
5092 -    def __setfield_contactp(self, value): 
5093          if isinstance(value,UINT): 
5094              self.__field_contactp=value 
5095          else: 
5096              self.__field_contactp=UINT(value,**{'sizeinbytes': 2}) 
5097   
5098 -    def __delfield_contactp(self): del self.__field_contactp 
5099   
5100      contactp=property(__getfield_contactp, __setfield_contactp, __delfield_contactp, "Pointer to contact number belongs") 
5101   
5102 -    def __getfield_email_len(self): 
5103          return self.__field_email_len.getvalue() 
5104   
5105 -    def __setfield_email_len(self, value): 
5106          if isinstance(value,UINT): 
5107              self.__field_email_len=value 
5108          else: 
5109              self.__field_email_len=UINT(value,**{'sizeinbytes': 1}) 
5110   
5111 -    def __delfield_email_len(self): del self.__field_email_len 
5112   
5113      email_len=property(__getfield_email_len, __setfield_email_len, __delfield_email_len, None) 
5114   
5115 -    def __getfield_email(self): 
5116          try: self.__field_email 
5117          except: 
5118              self.__field_email=USTRING(**{'sizeinbytes': 96, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
5119          return self.__field_email.getvalue() 
5120   
5121 -    def __setfield_email(self, value): 
5122          if isinstance(value,USTRING): 
5123              self.__field_email=value 
5124          else: 
5125              self.__field_email=USTRING(value,**{'sizeinbytes': 96, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
5126   
5127 -    def __delfield_email(self): del self.__field_email 
5128   
5129      email=property(__getfield_email, __setfield_email, __delfield_email, None) 
5130   
5131 -    def __getfield_pad(self): 
5132          try: self.__field_pad 
5133          except: 
5134              self.__field_pad=UNKNOWN(**{'sizeinbytes': 1}) 
5135          return self.__field_pad.getvalue() 
5136   
5137 -    def __setfield_pad(self, value): 
5138          if isinstance(value,UNKNOWN): 
5139              self.__field_pad=value 
5140          else: 
5141              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 1}) 
5142   
5143 -    def __delfield_pad(self): del self.__field_pad 
5144   
5145      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
5146   
5147 -    def __getfield_type(self): 
5148          try: self.__field_type 
5149          except: 
5150              self.__field_type=UINT(**{'sizeinbytes': 1, 'default': 8}) 
5151          return self.__field_type.getvalue() 
5152   
5153 -    def __setfield_type(self, value): 
5154          if isinstance(value,UINT): 
5155              self.__field_type=value 
5156          else: 
5157              self.__field_type=UINT(value,**{'sizeinbytes': 1, 'default': 8}) 
5158   
5159 -    def __delfield_type(self): del self.__field_type 
5160   
5161      type=property(__getfield_type, __setfield_type, __delfield_type, "7: Mobile, 8: Internet") 
5162   
5163 -    def iscontainer(self): 
5164          return True 
5165   
5166 -    def containerelements(self): 
5167          yield ('contactp', self.__field_contactp, "Pointer to contact number belongs") 
5168          yield ('email_len', self.__field_email_len, None) 
5169          yield ('email', self.__field_email, None) 
5170          yield ('pad', self.__field_pad, None) 
5171          yield ('type', self.__field_type, "7: Mobile, 8: Internet") 
5172   
5173   
5174   
5175   
5176 -class emailresponse(BaseProtogenClass): 
5177      __fields=['header', 'slot', 'entry'] 
5178   
5179 -    def __init__(self, *args, **kwargs): 
5180          dict={} 
5181          # What was supplied to this function 
5182          dict.update(kwargs) 
5183          # Parent constructor 
5184          super(emailresponse,self).__init__(**dict) 
5185          if self.__class__ is emailresponse: 
5186              self._update(args,dict) 
5187   
5188   
5189 -    def getfields(self): 
5190          return self.__fields 
5191   
5192   
5193 -    def _update(self, args, kwargs): 
5194          super(emailresponse,self)._update(args,kwargs) 
5195          keys=kwargs.keys() 
5196          for key in keys: 
5197              if key in self.__fields: 
5198                  setattr(self, key, kwargs[key]) 
5199                  del kwargs[key] 
5200          # Were any unrecognized kwargs passed in? 
5201          if __debug__: 
5202              self._complainaboutunusedargs(emailresponse,kwargs) 
5203          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
5204          # Make all P fields that haven't already been constructed 
5205   
5206   
5207 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
5208          'Writes this packet to the supplied buffer' 
5209          self._bufferstartoffset=buf.getcurrentoffset() 
5210          self.__field_header.writetobuffer(buf) 
5211          self.__field_slot.writetobuffer(buf) 
5212          self.__field_entry.writetobuffer(buf) 
5213          self._bufferendoffset=buf.getcurrentoffset() 
5214          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
5215   
5216   
5217 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
5218          'Reads this packet from the supplied buffer' 
5219          self._bufferstartoffset=buf.getcurrentoffset() 
5220          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
5221          self.__field_header=sanyoheader() 
5222          self.__field_header.readfrombuffer(buf) 
5223          self.__field_slot=UINT(**{'sizeinbytes': 2}) 
5224          self.__field_slot.readfrombuffer(buf) 
5225          self.__field_entry=emailentry() 
5226          self.__field_entry.readfrombuffer(buf) 
5227          self._bufferendoffset=buf.getcurrentoffset() 
5228   
5229   
5230 -    def __getfield_header(self): 
5231          return self.__field_header.getvalue() 
5232   
5233 -    def __setfield_header(self, value): 
5234          if isinstance(value,sanyoheader): 
5235              self.__field_header=value 
5236          else: 
5237              self.__field_header=sanyoheader(value,) 
5238   
5239 -    def __delfield_header(self): del self.__field_header 
5240   
5241      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
5242   
5243 -    def __getfield_slot(self): 
5244          return self.__field_slot.getvalue() 
5245   
5246 -    def __setfield_slot(self, value): 
5247          if isinstance(value,UINT): 
5248              self.__field_slot=value 
5249          else: 
5250              self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 
5251   
5252 -    def __delfield_slot(self): del self.__field_slot 
5253   
5254      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
5255   
5256 -    def __getfield_entry(self): 
5257          return self.__field_entry.getvalue() 
5258   
5259 -    def __setfield_entry(self, value): 
5260          if isinstance(value,emailentry): 
5261              self.__field_entry=value 
5262          else: 
5263              self.__field_entry=emailentry(value,) 
5264   
5265 -    def __delfield_entry(self): del self.__field_entry 
5266   
5267      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
5268   
5269 -    def iscontainer(self): 
5270          return True 
5271   
5272 -    def containerelements(self): 
5273          yield ('header', self.__field_header, None) 
5274          yield ('slot', self.__field_slot, None) 
5275          yield ('entry', self.__field_entry, None) 
5276   
5277   
5278   
5279   
5280 -class emailupdaterequest(BaseProtogenClass): 
5281      __fields=['header', 'slot', 'entry'] 
5282   
5283 -    def __init__(self, *args, **kwargs): 
5284          dict={} 
5285          # What was supplied to this function 
5286          dict.update(kwargs) 
5287          # Parent constructor 
5288          super(emailupdaterequest,self).__init__(**dict) 
5289          if self.__class__ is emailupdaterequest: 
5290              self._update(args,dict) 
5291   
5292   
5293 -    def getfields(self): 
5294          return self.__fields 
5295   
5296   
5297 -    def _update(self, args, kwargs): 
5298          super(emailupdaterequest,self)._update(args,kwargs) 
5299          keys=kwargs.keys() 
5300          for key in keys: 
5301              if key in self.__fields: 
5302                  setattr(self, key, kwargs[key]) 
5303                  del kwargs[key] 
5304          # Were any unrecognized kwargs passed in? 
5305          if __debug__: 
5306              self._complainaboutunusedargs(emailupdaterequest,kwargs) 
5307          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
5308          # Make all P fields that haven't already been constructed 
5309   
5310   
5311 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
5312          'Writes this packet to the supplied buffer' 
5313          self._bufferstartoffset=buf.getcurrentoffset() 
5314          try: self.__field_header 
5315          except: 
5316              self.__field_header=sanyowriteheader(**{'packettype': 0x16,                   'command': 0x93}) 
5317          self.__field_header.writetobuffer(buf) 
5318          self.__field_slot.writetobuffer(buf) 
5319          try: self.__field_entry 
5320          except: 
5321              self.__field_entry=emailentry() 
5322          self.__field_entry.writetobuffer(buf) 
5323          self._bufferendoffset=buf.getcurrentoffset() 
5324          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
5325   
5326   
5327 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
5328          'Reads this packet from the supplied buffer' 
5329          self._bufferstartoffset=buf.getcurrentoffset() 
5330          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
5331          self.__field_header=sanyowriteheader(**{'packettype': 0x16,                   'command': 0x93}) 
5332          self.__field_header.readfrombuffer(buf) 
5333          self.__field_slot=UINT(**{'sizeinbytes': 2}) 
5334          self.__field_slot.readfrombuffer(buf) 
5335          self.__field_entry=emailentry() 
5336          self.__field_entry.readfrombuffer(buf) 
5337          self._bufferendoffset=buf.getcurrentoffset() 
5338   
5339   
5340 -    def __getfield_header(self): 
5341          try: self.__field_header 
5342          except: 
5343              self.__field_header=sanyowriteheader(**{'packettype': 0x16,                   'command': 0x93}) 
5344          return self.__field_header.getvalue() 
5345   
5346 -    def __setfield_header(self, value): 
5347          if isinstance(value,sanyowriteheader): 
5348              self.__field_header=value 
5349          else: 
5350              self.__field_header=sanyowriteheader(value,**{'packettype': 0x16,                   'command': 0x93}) 
5351   
5352 -    def __delfield_header(self): del self.__field_header 
5353   
5354      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
5355   
5356 -    def __getfield_slot(self): 
5357          return self.__field_slot.getvalue() 
5358   
5359 -    def __setfield_slot(self, value): 
5360          if isinstance(value,UINT): 
5361              self.__field_slot=value 
5362          else: 
5363              self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 
5364   
5365 -    def __delfield_slot(self): del self.__field_slot 
5366   
5367      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
5368   
5369 -    def __getfield_entry(self): 
5370          try: self.__field_entry 
5371          except: 
5372              self.__field_entry=emailentry() 
5373          return self.__field_entry.getvalue() 
5374   
5375 -    def __setfield_entry(self, value): 
5376          if isinstance(value,emailentry): 
5377              self.__field_entry=value 
5378          else: 
5379              self.__field_entry=emailentry(value,) 
5380   
5381 -    def __delfield_entry(self): del self.__field_entry 
5382   
5383      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
5384   
5385 -    def iscontainer(self): 
5386          return True 
5387   
5388 -    def containerelements(self): 
5389          yield ('header', self.__field_header, None) 
5390          yield ('slot', self.__field_slot, None) 
5391          yield ('entry', self.__field_entry, None) 
5392   
5393   
5394   
5395   
5396 -class grouprequest(BaseProtogenClass): 
5397      __fields=['header', 'slot'] 
5398   
5399 -    def __init__(self, *args, **kwargs): 
5400          dict={} 
5401          # What was supplied to this function 
5402          dict.update(kwargs) 
5403          # Parent constructor 
5404          super(grouprequest,self).__init__(**dict) 
5405          if self.__class__ is grouprequest: 
5406              self._update(args,dict) 
5407   
5408   
5409 -    def getfields(self): 
5410          return self.__fields 
5411   
5412   
5413 -    def _update(self, args, kwargs): 
5414          super(grouprequest,self)._update(args,kwargs) 
5415          keys=kwargs.keys() 
5416          for key in keys: 
5417              if key in self.__fields: 
5418                  setattr(self, key, kwargs[key]) 
5419                  del kwargs[key] 
5420          # Were any unrecognized kwargs passed in? 
5421          if __debug__: 
5422              self._complainaboutunusedargs(grouprequest,kwargs) 
5423          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
5424          # Make all P fields that haven't already been constructed 
5425   
5426   
5427 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
5428          'Writes this packet to the supplied buffer' 
5429          self._bufferstartoffset=buf.getcurrentoffset() 
5430          try: self.__field_header 
5431          except: 
5432              self.__field_header=sanyoheader(**{'packettype': 0x16,                   'command': 0x87}) 
5433          self.__field_header.writetobuffer(buf) 
5434          self.__field_slot.writetobuffer(buf) 
5435          self._bufferendoffset=buf.getcurrentoffset() 
5436          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
5437   
5438   
5439 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
5440          'Reads this packet from the supplied buffer' 
5441          self._bufferstartoffset=buf.getcurrentoffset() 
5442          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
5443          self.__field_header=sanyoheader(**{'packettype': 0x16,                   'command': 0x87}) 
5444          self.__field_header.readfrombuffer(buf) 
5445          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
5446          self.__field_slot.readfrombuffer(buf) 
5447          self._bufferendoffset=buf.getcurrentoffset() 
5448   
5449   
5450 -    def __getfield_header(self): 
5451          try: self.__field_header 
5452          except: 
5453              self.__field_header=sanyoheader(**{'packettype': 0x16,                   'command': 0x87}) 
5454          return self.__field_header.getvalue() 
5455   
5456 -    def __setfield_header(self, value): 
5457          if isinstance(value,sanyoheader): 
5458              self.__field_header=value 
5459          else: 
5460              self.__field_header=sanyoheader(value,**{'packettype': 0x16,                   'command': 0x87}) 
5461   
5462 -    def __delfield_header(self): del self.__field_header 
5463   
5464      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
5465   
5466 -    def __getfield_slot(self): 
5467          return self.__field_slot.getvalue() 
5468   
5469 -    def __setfield_slot(self, value): 
5470          if isinstance(value,UINT): 
5471              self.__field_slot=value 
5472          else: 
5473              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
5474   
5475 -    def __delfield_slot(self): del self.__field_slot 
5476   
5477      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
5478   
5479 -    def iscontainer(self): 
5480          return True 
5481   
5482 -    def containerelements(self): 
5483          yield ('header', self.__field_header, None) 
5484          yield ('slot', self.__field_slot, None) 
5485   
5486   
5487   
5488   
5489 -class groupentry(BaseProtogenClass): 
5490      __fields=['slot', 'groupname_len', 'groupname', 'ringer', 'picture'] 
5491   
5492 -    def __init__(self, *args, **kwargs): 
5493          dict={} 
5494          # What was supplied to this function 
5495          dict.update(kwargs) 
5496          # Parent constructor 
5497          super(groupentry,self).__init__(**dict) 
5498          if self.__class__ is groupentry: 
5499              self._update(args,dict) 
5500   
5501   
5502 -    def getfields(self): 
5503          return self.__fields 
5504   
5505   
5506 -    def _update(self, args, kwargs): 
5507          super(groupentry,self)._update(args,kwargs) 
5508          keys=kwargs.keys() 
5509          for key in keys: 
5510              if key in self.__fields: 
5511                  setattr(self, key, kwargs[key]) 
5512                  del kwargs[key] 
5513          # Were any unrecognized kwargs passed in? 
5514          if __debug__: 
5515              self._complainaboutunusedargs(groupentry,kwargs) 
5516          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
5517          # Make all P fields that haven't already been constructed 
5518   
5519   
5520 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
5521          'Writes this packet to the supplied buffer' 
5522          self._bufferstartoffset=buf.getcurrentoffset() 
5523          self.__field_slot.writetobuffer(buf) 
5524          self.__field_groupname_len.writetobuffer(buf) 
5525          try: self.__field_groupname 
5526          except: 
5527              self.__field_groupname=USTRING(**{'sizeinbytes': 16, 'default': ""}) 
5528          self.__field_groupname.writetobuffer(buf) 
5529          try: self.__field_ringer 
5530          except: 
5531              self.__field_ringer=UINT(**{'sizeinbytes': 2, 'default': 0xfff0}) 
5532          self.__field_ringer.writetobuffer(buf) 
5533          try: self.__field_picture 
5534          except: 
5535              self.__field_picture=UINT(**{'sizeinbytes': 2, 'default': 0xfffe}) 
5536          self.__field_picture.writetobuffer(buf) 
5537          self._bufferendoffset=buf.getcurrentoffset() 
5538          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
5539   
5540   
5541 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
5542          'Reads this packet from the supplied buffer' 
5543          self._bufferstartoffset=buf.getcurrentoffset() 
5544          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
5545          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
5546          self.__field_slot.readfrombuffer(buf) 
5547          self.__field_groupname_len=UINT(**{'sizeinbytes': 1}) 
5548          self.__field_groupname_len.readfrombuffer(buf) 
5549          self.__field_groupname=USTRING(**{'sizeinbytes': 16, 'default': ""}) 
5550          self.__field_groupname.readfrombuffer(buf) 
5551          self.__field_ringer=UINT(**{'sizeinbytes': 2, 'default': 0xfff0}) 
5552          self.__field_ringer.readfrombuffer(buf) 
5553          self.__field_picture=UINT(**{'sizeinbytes': 2, 'default': 0xfffe}) 
5554          self.__field_picture.readfrombuffer(buf) 
5555          self._bufferendoffset=buf.getcurrentoffset() 
5556   
5557   
5558 -    def __getfield_slot(self): 
5559          return self.__field_slot.getvalue() 
5560   
5561 -    def __setfield_slot(self, value): 
5562          if isinstance(value,UINT): 
5563              self.__field_slot=value 
5564          else: 
5565              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
5566   
5567 -    def __delfield_slot(self): del self.__field_slot 
5568   
5569      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
5570   
5571 -    def __getfield_groupname_len(self): 
5572          return self.__field_groupname_len.getvalue() 
5573   
5574 -    def __setfield_groupname_len(self, value): 
5575          if isinstance(value,UINT): 
5576              self.__field_groupname_len=value 
5577          else: 
5578              self.__field_groupname_len=UINT(value,**{'sizeinbytes': 1}) 
5579   
5580 -    def __delfield_groupname_len(self): del self.__field_groupname_len 
5581   
5582      groupname_len=property(__getfield_groupname_len, __setfield_groupname_len, __delfield_groupname_len, None) 
5583   
5584 -    def __getfield_groupname(self): 
5585          try: self.__field_groupname 
5586          except: 
5587              self.__field_groupname=USTRING(**{'sizeinbytes': 16, 'default': ""}) 
5588          return self.__field_groupname.getvalue() 
5589   
5590 -    def __setfield_groupname(self, value): 
5591          if isinstance(value,USTRING): 
5592              self.__field_groupname=value 
5593          else: 
5594              self.__field_groupname=USTRING(value,**{'sizeinbytes': 16, 'default': ""}) 
5595   
5596 -    def __delfield_groupname(self): del self.__field_groupname 
5597   
5598      groupname=property(__getfield_groupname, __setfield_groupname, __delfield_groupname, None) 
5599   
5600 -    def __getfield_ringer(self): 
5601          try: self.__field_ringer 
5602          except: 
5603              self.__field_ringer=UINT(**{'sizeinbytes': 2, 'default': 0xfff0}) 
5604          return self.__field_ringer.getvalue() 
5605   
5606 -    def __setfield_ringer(self, value): 
5607          if isinstance(value,UINT): 
5608              self.__field_ringer=value 
5609          else: 
5610              self.__field_ringer=UINT(value,**{'sizeinbytes': 2, 'default': 0xfff0}) 
5611   
5612 -    def __delfield_ringer(self): del self.__field_ringer 
5613   
5614      ringer=property(__getfield_ringer, __setfield_ringer, __delfield_ringer, None) 
5615   
5616 -    def __getfield_picture(self): 
5617          try: self.__field_picture 
5618          except: 
5619              self.__field_picture=UINT(**{'sizeinbytes': 2, 'default': 0xfffe}) 
5620          return self.__field_picture.getvalue() 
5621   
5622 -    def __setfield_picture(self, value): 
5623          if isinstance(value,UINT): 
5624              self.__field_picture=value 
5625          else: 
5626              self.__field_picture=UINT(value,**{'sizeinbytes': 2, 'default': 0xfffe}) 
5627   
5628 -    def __delfield_picture(self): del self.__field_picture 
5629   
5630      picture=property(__getfield_picture, __setfield_picture, __delfield_picture, None) 
5631   
5632 -    def iscontainer(self): 
5633          return True 
5634   
5635 -    def containerelements(self): 
5636          yield ('slot', self.__field_slot, None) 
5637          yield ('groupname_len', self.__field_groupname_len, None) 
5638          yield ('groupname', self.__field_groupname, None) 
5639          yield ('ringer', self.__field_ringer, None) 
5640          yield ('picture', self.__field_picture, None) 
5641   
5642   
5643   
5644   
5645 -class groupresponse(BaseProtogenClass): 
5646      __fields=['header', 'slot', 'entry', 'pad'] 
5647   
5648 -    def __init__(self, *args, **kwargs): 
5649          dict={} 
5650          # What was supplied to this function 
5651          dict.update(kwargs) 
5652          # Parent constructor 
5653          super(groupresponse,self).__init__(**dict) 
5654          if self.__class__ is groupresponse: 
5655              self._update(args,dict) 
5656   
5657   
5658 -    def getfields(self): 
5659          return self.__fields 
5660   
5661   
5662 -    def _update(self, args, kwargs): 
5663          super(groupresponse,self)._update(args,kwargs) 
5664          keys=kwargs.keys() 
5665          for key in keys: 
5666              if key in self.__fields: 
5667                  setattr(self, key, kwargs[key]) 
5668                  del kwargs[key] 
5669          # Were any unrecognized kwargs passed in? 
5670          if __debug__: 
5671              self._complainaboutunusedargs(groupresponse,kwargs) 
5672          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
5673          # Make all P fields that haven't already been constructed 
5674   
5675   
5676 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
5677          'Writes this packet to the supplied buffer' 
5678          self._bufferstartoffset=buf.getcurrentoffset() 
5679          self.__field_header.writetobuffer(buf) 
5680          self.__field_slot.writetobuffer(buf) 
5681          self.__field_entry.writetobuffer(buf) 
5682          self.__field_pad.writetobuffer(buf) 
5683          self._bufferendoffset=buf.getcurrentoffset() 
5684          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
5685   
5686   
5687 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
5688          'Reads this packet from the supplied buffer' 
5689          self._bufferstartoffset=buf.getcurrentoffset() 
5690          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
5691          self.__field_header=sanyoheader() 
5692          self.__field_header.readfrombuffer(buf) 
5693          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
5694          self.__field_slot.readfrombuffer(buf) 
5695          self.__field_entry=groupentry() 
5696          self.__field_entry.readfrombuffer(buf) 
5697          self.__field_pad=UNKNOWN() 
5698          self.__field_pad.readfrombuffer(buf) 
5699          self._bufferendoffset=buf.getcurrentoffset() 
5700   
5701   
5702 -    def __getfield_header(self): 
5703          return self.__field_header.getvalue() 
5704   
5705 -    def __setfield_header(self, value): 
5706          if isinstance(value,sanyoheader): 
5707              self.__field_header=value 
5708          else: 
5709              self.__field_header=sanyoheader(value,) 
5710   
5711 -    def __delfield_header(self): del self.__field_header 
5712   
5713      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
5714   
5715 -    def __getfield_slot(self): 
5716          return self.__field_slot.getvalue() 
5717   
5718 -    def __setfield_slot(self, value): 
5719          if isinstance(value,UINT): 
5720              self.__field_slot=value 
5721          else: 
5722              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
5723   
5724 -    def __delfield_slot(self): del self.__field_slot 
5725   
5726      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
5727   
5728 -    def __getfield_entry(self): 
5729          return self.__field_entry.getvalue() 
5730   
5731 -    def __setfield_entry(self, value): 
5732          if isinstance(value,groupentry): 
5733              self.__field_entry=value 
5734          else: 
5735              self.__field_entry=groupentry(value,) 
5736   
5737 -    def __delfield_entry(self): del self.__field_entry 
5738   
5739      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
5740   
5741 -    def __getfield_pad(self): 
5742          return self.__field_pad.getvalue() 
5743   
5744 -    def __setfield_pad(self, value): 
5745          if isinstance(value,UNKNOWN): 
5746              self.__field_pad=value 
5747          else: 
5748              self.__field_pad=UNKNOWN(value,) 
5749   
5750 -    def __delfield_pad(self): del self.__field_pad 
5751   
5752      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
5753   
5754 -    def iscontainer(self): 
5755          return True 
5756   
5757 -    def containerelements(self): 
5758          yield ('header', self.__field_header, None) 
5759          yield ('slot', self.__field_slot, None) 
5760          yield ('entry', self.__field_entry, None) 
5761          yield ('pad', self.__field_pad, None) 
5762   
5763   
5764   
5765   
5766 -class groupupdaterequest(BaseProtogenClass): 
5767      __fields=['header', 'slot', 'entry', 'pad'] 
5768   
5769 -    def __init__(self, *args, **kwargs): 
5770          dict={} 
5771          # What was supplied to this function 
5772          dict.update(kwargs) 
5773          # Parent constructor 
5774          super(groupupdaterequest,self).__init__(**dict) 
5775          if self.__class__ is groupupdaterequest: 
5776              self._update(args,dict) 
5777   
5778   
5779 -    def getfields(self): 
5780          return self.__fields 
5781   
5782   
5783 -    def _update(self, args, kwargs): 
5784          super(groupupdaterequest,self)._update(args,kwargs) 
5785          keys=kwargs.keys() 
5786          for key in keys: 
5787              if key in self.__fields: 
5788                  setattr(self, key, kwargs[key]) 
5789                  del kwargs[key] 
5790          # Were any unrecognized kwargs passed in? 
5791          if __debug__: 
5792              self._complainaboutunusedargs(groupupdaterequest,kwargs) 
5793          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
5794          # Make all P fields that haven't already been constructed 
5795   
5796   
5797 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
5798          'Writes this packet to the supplied buffer' 
5799          self._bufferstartoffset=buf.getcurrentoffset() 
5800          try: self.__field_header 
5801          except: 
5802              self.__field_header=sanyowriteheader(**{'packettype': 0x16,                   'command': 0x87}) 
5803          self.__field_header.writetobuffer(buf) 
5804          self.__field_slot.writetobuffer(buf) 
5805          self.__field_entry.writetobuffer(buf) 
5806          self.__field_pad.writetobuffer(buf) 
5807          self._bufferendoffset=buf.getcurrentoffset() 
5808          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
5809   
5810   
5811 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
5812          'Reads this packet from the supplied buffer' 
5813          self._bufferstartoffset=buf.getcurrentoffset() 
5814          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
5815          self.__field_header=sanyowriteheader(**{'packettype': 0x16,                   'command': 0x87}) 
5816          self.__field_header.readfrombuffer(buf) 
5817          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
5818          self.__field_slot.readfrombuffer(buf) 
5819          self.__field_entry=groupentry() 
5820          self.__field_entry.readfrombuffer(buf) 
5821          self.__field_pad=UNKNOWN() 
5822          self.__field_pad.readfrombuffer(buf) 
5823          self._bufferendoffset=buf.getcurrentoffset() 
5824   
5825   
5826 -    def __getfield_header(self): 
5827          try: self.__field_header 
5828          except: 
5829              self.__field_header=sanyowriteheader(**{'packettype': 0x16,                   'command': 0x87}) 
5830          return self.__field_header.getvalue() 
5831   
5832 -    def __setfield_header(self, value): 
5833          if isinstance(value,sanyowriteheader): 
5834              self.__field_header=value 
5835          else: 
5836              self.__field_header=sanyowriteheader(value,**{'packettype': 0x16,                   'command': 0x87}) 
5837   
5838 -    def __delfield_header(self): del self.__field_header 
5839   
5840      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
5841   
5842 -    def __getfield_slot(self): 
5843          return self.__field_slot.getvalue() 
5844   
5845 -    def __setfield_slot(self, value): 
5846          if isinstance(value,UINT): 
5847              self.__field_slot=value 
5848          else: 
5849              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
5850   
5851 -    def __delfield_slot(self): del self.__field_slot 
5852   
5853      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
5854   
5855 -    def __getfield_entry(self): 
5856          return self.__field_entry.getvalue() 
5857   
5858 -    def __setfield_entry(self, value): 
5859          if isinstance(value,groupentry): 
5860              self.__field_entry=value 
5861          else: 
5862              self.__field_entry=groupentry(value,) 
5863   
5864 -    def __delfield_entry(self): del self.__field_entry 
5865   
5866      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
5867   
5868 -    def __getfield_pad(self): 
5869          return self.__field_pad.getvalue() 
5870   
5871 -    def __setfield_pad(self, value): 
5872          if isinstance(value,UNKNOWN): 
5873              self.__field_pad=value 
5874          else: 
5875              self.__field_pad=UNKNOWN(value,) 
5876   
5877 -    def __delfield_pad(self): del self.__field_pad 
5878   
5879      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
5880   
5881 -    def iscontainer(self): 
5882          return True 
5883   
5884 -    def containerelements(self): 
5885          yield ('header', self.__field_header, None) 
5886          yield ('slot', self.__field_slot, None) 
5887          yield ('entry', self.__field_entry, None) 
5888          yield ('pad', self.__field_pad, None) 
5889   
5890   
5891   
5892   
5893 -class evententry(BaseProtogenClass): 
5894      __fields=['alarm', 'slot', 'eventname', 'pad1', 'eventname_len', 'start', 'end', 'location', 'pad2', 'location_len', 'alarmdiff', 'period', 'dom', 'timestamp', 'pad3', 'serial', 'pad4', 'ringtone'] 
5895   
5896 -    def __init__(self, *args, **kwargs): 
5897          dict={} 
5898          # What was supplied to this function 
5899          dict.update(kwargs) 
5900          # Parent constructor 
5901          super(evententry,self).__init__(**dict) 
5902          if self.__class__ is evententry: 
5903              self._update(args,dict) 
5904   
5905   
5906 -    def getfields(self): 
5907          return self.__fields 
5908   
5909   
5910 -    def _update(self, args, kwargs): 
5911          super(evententry,self)._update(args,kwargs) 
5912          keys=kwargs.keys() 
5913          for key in keys: 
5914              if key in self.__fields: 
5915                  setattr(self, key, kwargs[key]) 
5916                  del kwargs[key] 
5917          # Were any unrecognized kwargs passed in? 
5918          if __debug__: 
5919              self._complainaboutunusedargs(evententry,kwargs) 
5920          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
5921          # Make all P fields that haven't already been constructed 
5922          try: self.__field_alarm 
5923          except: 
5924              self.__field_alarm=UINT(**{'default': 0xffffffff}) 
5925   
5926   
5927 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
5928          'Writes this packet to the supplied buffer' 
5929          self._bufferstartoffset=buf.getcurrentoffset() 
5930          self.__field_slot.writetobuffer(buf) 
5931          self.__field_eventname.writetobuffer(buf) 
5932          try: self.__field_pad1 
5933          except: 
5934              self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7}) 
5935          self.__field_pad1.writetobuffer(buf) 
5936          self.__field_eventname_len.writetobuffer(buf) 
5937          self.__field_start.writetobuffer(buf) 
5938          self.__field_end.writetobuffer(buf) 
5939          self.__field_location.writetobuffer(buf) 
5940          try: self.__field_pad2 
5941          except: 
5942              self.__field_pad2=UNKNOWN(**{'sizeinbytes': 7}) 
5943          self.__field_pad2.writetobuffer(buf) 
5944          self.__field_location_len.writetobuffer(buf) 
5945          self.__field_alarmdiff.writetobuffer(buf) 
5946          self.__field_period.writetobuffer(buf) 
5947          self.__field_dom.writetobuffer(buf) 
5948          try: self.__field_timestamp 
5949          except: 
5950              self.__field_timestamp=UINT(**{'sizeinbytes': 4, 'default': 0}) 
5951          self.__field_timestamp.writetobuffer(buf) 
5952          try: self.__field_pad3 
5953          except: 
5954              self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1}) 
5955          self.__field_pad3.writetobuffer(buf) 
5956          try: self.__field_serial 
5957          except: 
5958              self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 
5959          self.__field_serial.writetobuffer(buf) 
5960          try: self.__field_pad4 
5961          except: 
5962              self.__field_pad4=UNKNOWN(**{'sizeinbytes': 3}) 
5963          self.__field_pad4.writetobuffer(buf) 
5964          self.__field_ringtone.writetobuffer(buf) 
5965          self._bufferendoffset=buf.getcurrentoffset() 
5966          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
5967   
5968   
5969 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
5970          'Reads this packet from the supplied buffer' 
5971          self._bufferstartoffset=buf.getcurrentoffset() 
5972          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
5973          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
5974          self.__field_slot.readfrombuffer(buf) 
5975          self.__field_eventname=USTRING(**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
5976          self.__field_eventname.readfrombuffer(buf) 
5977          self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7}) 
5978          self.__field_pad1.readfrombuffer(buf) 
5979          self.__field_eventname_len=UINT(**{'sizeinbytes': 1}) 
5980          self.__field_eventname_len.readfrombuffer(buf) 
5981          self.__field_start=UINT(**{'sizeinbytes': 4}) 
5982          self.__field_start.readfrombuffer(buf) 
5983          self.__field_end=UINT(**{'sizeinbytes': 4}) 
5984          self.__field_end.readfrombuffer(buf) 
5985          self.__field_location=USTRING(**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
5986          self.__field_location.readfrombuffer(buf) 
5987          self.__field_pad2=UNKNOWN(**{'sizeinbytes': 7}) 
5988          self.__field_pad2.readfrombuffer(buf) 
5989          self.__field_location_len=UINT(**{'sizeinbytes': 1}) 
5990          self.__field_location_len.readfrombuffer(buf) 
5991          self.__field_alarmdiff=UINT(**{'sizeinbytes': 4}) 
5992          self.__field_alarmdiff.readfrombuffer(buf) 
5993          self.__field_period=UINT(**{'sizeinbytes': 1}) 
5994          self.__field_period.readfrombuffer(buf) 
5995          self.__field_dom=UINT(**{'sizeinbytes': 1}) 
5996          self.__field_dom.readfrombuffer(buf) 
5997          self.__field_timestamp=UINT(**{'sizeinbytes': 4, 'default': 0}) 
5998          self.__field_timestamp.readfrombuffer(buf) 
5999          self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1}) 
6000          self.__field_pad3.readfrombuffer(buf) 
6001          self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 
6002          self.__field_serial.readfrombuffer(buf) 
6003          self.__field_pad4=UNKNOWN(**{'sizeinbytes': 3}) 
6004          self.__field_pad4.readfrombuffer(buf) 
6005          self.__field_ringtone=UINT(**{'sizeinbytes': 2}) 
6006          self.__field_ringtone.readfrombuffer(buf) 
6007          self._bufferendoffset=buf.getcurrentoffset() 
6008   
6009   
6010 -    def __getfield_alarm(self): 
6011          try: self.__field_alarm 
6012          except: 
6013              self.__field_alarm=UINT(**{'default': 0xffffffff}) 
6014          return self.__field_alarm.getvalue() 
6015   
6016 -    def __setfield_alarm(self, value): 
6017          if isinstance(value,UINT): 
6018              self.__field_alarm=value 
6019          else: 
6020              self.__field_alarm=UINT(value,**{'default': 0xffffffff}) 
6021   
6022 -    def __delfield_alarm(self): del self.__field_alarm 
6023   
6024      alarm=property(__getfield_alarm, __setfield_alarm, __delfield_alarm, None) 
6025   
6026 -    def __getfield_slot(self): 
6027          return self.__field_slot.getvalue() 
6028   
6029 -    def __setfield_slot(self, value): 
6030          if isinstance(value,UINT): 
6031              self.__field_slot=value 
6032          else: 
6033              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
6034   
6035 -    def __delfield_slot(self): del self.__field_slot 
6036   
6037      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
6038   
6039 -    def __getfield_eventname(self): 
6040          return self.__field_eventname.getvalue() 
6041   
6042 -    def __setfield_eventname(self, value): 
6043          if isinstance(value,USTRING): 
6044              self.__field_eventname=value 
6045          else: 
6046              self.__field_eventname=USTRING(value,**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
6047   
6048 -    def __delfield_eventname(self): del self.__field_eventname 
6049   
6050      eventname=property(__getfield_eventname, __setfield_eventname, __delfield_eventname, None) 
6051   
6052 -    def __getfield_pad1(self): 
6053          try: self.__field_pad1 
6054          except: 
6055              self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7}) 
6056          return self.__field_pad1.getvalue() 
6057   
6058 -    def __setfield_pad1(self, value): 
6059          if isinstance(value,UNKNOWN): 
6060              self.__field_pad1=value 
6061          else: 
6062              self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 7}) 
6063   
6064 -    def __delfield_pad1(self): del self.__field_pad1 
6065   
6066      pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None) 
6067   
6068 -    def __getfield_eventname_len(self): 
6069          return self.__field_eventname_len.getvalue() 
6070   
6071 -    def __setfield_eventname_len(self, value): 
6072          if isinstance(value,UINT): 
6073              self.__field_eventname_len=value 
6074          else: 
6075              self.__field_eventname_len=UINT(value,**{'sizeinbytes': 1}) 
6076   
6077 -    def __delfield_eventname_len(self): del self.__field_eventname_len 
6078   
6079      eventname_len=property(__getfield_eventname_len, __setfield_eventname_len, __delfield_eventname_len, None) 
6080   
6081 -    def __getfield_start(self): 
6082          return self.__field_start.getvalue() 
6083   
6084 -    def __setfield_start(self, value): 
6085          if isinstance(value,UINT): 
6086              self.__field_start=value 
6087          else: 
6088              self.__field_start=UINT(value,**{'sizeinbytes': 4}) 
6089   
6090 -    def __delfield_start(self): del self.__field_start 
6091   
6092      start=property(__getfield_start, __setfield_start, __delfield_start, "# seconds since Jan 1, 1980 approximately") 
6093   
6094 -    def __getfield_end(self): 
6095          return self.__field_end.getvalue() 
6096   
6097 -    def __setfield_end(self, value): 
6098          if isinstance(value,UINT): 
6099              self.__field_end=value 
6100          else: 
6101              self.__field_end=UINT(value,**{'sizeinbytes': 4}) 
6102   
6103 -    def __delfield_end(self): del self.__field_end 
6104   
6105      end=property(__getfield_end, __setfield_end, __delfield_end, None) 
6106   
6107 -    def __getfield_location(self): 
6108          return self.__field_location.getvalue() 
6109   
6110 -    def __setfield_location(self, value): 
6111          if isinstance(value,USTRING): 
6112              self.__field_location=value 
6113          else: 
6114              self.__field_location=USTRING(value,**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
6115   
6116 -    def __delfield_location(self): del self.__field_location 
6117   
6118      location=property(__getfield_location, __setfield_location, __delfield_location, None) 
6119   
6120 -    def __getfield_pad2(self): 
6121          try: self.__field_pad2 
6122          except: 
6123              self.__field_pad2=UNKNOWN(**{'sizeinbytes': 7}) 
6124          return self.__field_pad2.getvalue() 
6125   
6126 -    def __setfield_pad2(self, value): 
6127          if isinstance(value,UNKNOWN): 
6128              self.__field_pad2=value 
6129          else: 
6130              self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 7}) 
6131   
6132 -    def __delfield_pad2(self): del self.__field_pad2 
6133   
6134      pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None) 
6135   
6136 -    def __getfield_location_len(self): 
6137          return self.__field_location_len.getvalue() 
6138   
6139 -    def __setfield_location_len(self, value): 
6140          if isinstance(value,UINT): 
6141              self.__field_location_len=value 
6142          else: 
6143              self.__field_location_len=UINT(value,**{'sizeinbytes': 1}) 
6144   
6145 -    def __delfield_location_len(self): del self.__field_location_len 
6146   
6147      location_len=property(__getfield_location_len, __setfield_location_len, __delfield_location_len, None) 
6148   
6149 -    def __getfield_alarmdiff(self): 
6150          return self.__field_alarmdiff.getvalue() 
6151   
6152 -    def __setfield_alarmdiff(self, value): 
6153          if isinstance(value,UINT): 
6154              self.__field_alarmdiff=value 
6155          else: 
6156              self.__field_alarmdiff=UINT(value,**{'sizeinbytes': 4}) 
6157   
6158 -    def __delfield_alarmdiff(self): del self.__field_alarmdiff 
6159   
6160      alarmdiff=property(__getfield_alarmdiff, __setfield_alarmdiff, __delfield_alarmdiff, "Displayed alarm time") 
6161   
6162 -    def __getfield_period(self): 
6163          return self.__field_period.getvalue() 
6164   
6165 -    def __setfield_period(self, value): 
6166          if isinstance(value,UINT): 
6167              self.__field_period=value 
6168          else: 
6169              self.__field_period=UINT(value,**{'sizeinbytes': 1}) 
6170   
6171 -    def __delfield_period(self): del self.__field_period 
6172   
6173      period=property(__getfield_period, __setfield_period, __delfield_period, "No, Daily, Weekly, Monthly, Yearly") 
6174   
6175 -    def __getfield_dom(self): 
6176          return self.__field_dom.getvalue() 
6177   
6178 -    def __setfield_dom(self, value): 
6179          if isinstance(value,UINT): 
6180              self.__field_dom=value 
6181          else: 
6182              self.__field_dom=UINT(value,**{'sizeinbytes': 1}) 
6183   
6184 -    def __delfield_dom(self): del self.__field_dom 
6185   
6186      dom=property(__getfield_dom, __setfield_dom, __delfield_dom, "Day of month for the event") 
6187   
6188 -    def __getfield_timestamp(self): 
6189          try: self.__field_timestamp 
6190          except: 
6191              self.__field_timestamp=UINT(**{'sizeinbytes': 4, 'default': 0}) 
6192          return self.__field_timestamp.getvalue() 
6193   
6194 -    def __setfield_timestamp(self, value): 
6195          if isinstance(value,UINT): 
6196              self.__field_timestamp=value 
6197          else: 
6198              self.__field_timestamp=UINT(value,**{'sizeinbytes': 4, 'default': 0}) 
6199   
6200 -    def __delfield_timestamp(self): del self.__field_timestamp 
6201   
6202      timestamp=property(__getfield_timestamp, __setfield_timestamp, __delfield_timestamp, None) 
6203   
6204 -    def __getfield_pad3(self): 
6205          try: self.__field_pad3 
6206          except: 
6207              self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1}) 
6208          return self.__field_pad3.getvalue() 
6209   
6210 -    def __setfield_pad3(self, value): 
6211          if isinstance(value,UNKNOWN): 
6212              self.__field_pad3=value 
6213          else: 
6214              self.__field_pad3=UNKNOWN(value,**{'sizeinbytes': 1}) 
6215   
6216 -    def __delfield_pad3(self): del self.__field_pad3 
6217   
6218      pad3=property(__getfield_pad3, __setfield_pad3, __delfield_pad3, None) 
6219   
6220 -    def __getfield_serial(self): 
6221          try: self.__field_serial 
6222          except: 
6223              self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 
6224          return self.__field_serial.getvalue() 
6225   
6226 -    def __setfield_serial(self, value): 
6227          if isinstance(value,UINT): 
6228              self.__field_serial=value 
6229          else: 
6230              self.__field_serial=UINT(value,**{'sizeinbytes': 1, 'default': 0}) 
6231   
6232 -    def __delfield_serial(self): del self.__field_serial 
6233   
6234      serial=property(__getfield_serial, __setfield_serial, __delfield_serial, "Some kind of serial number") 
6235   
6236 -    def __getfield_pad4(self): 
6237          try: self.__field_pad4 
6238          except: 
6239              self.__field_pad4=UNKNOWN(**{'sizeinbytes': 3}) 
6240          return self.__field_pad4.getvalue() 
6241   
6242 -    def __setfield_pad4(self, value): 
6243          if isinstance(value,UNKNOWN): 
6244              self.__field_pad4=value 
6245          else: 
6246              self.__field_pad4=UNKNOWN(value,**{'sizeinbytes': 3}) 
6247   
6248 -    def __delfield_pad4(self): del self.__field_pad4 
6249   
6250      pad4=property(__getfield_pad4, __setfield_pad4, __delfield_pad4, None) 
6251   
6252 -    def __getfield_ringtone(self): 
6253          return self.__field_ringtone.getvalue() 
6254   
6255 -    def __setfield_ringtone(self, value): 
6256          if isinstance(value,UINT): 
6257              self.__field_ringtone=value 
6258          else: 
6259              self.__field_ringtone=UINT(value,**{'sizeinbytes': 2}) 
6260   
6261 -    def __delfield_ringtone(self): del self.__field_ringtone 
6262   
6263      ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 
6264   
6265 -    def iscontainer(self): 
6266          return True 
6267   
6268 -    def containerelements(self): 
6269          yield ('alarm', self.__field_alarm, None) 
6270          yield ('slot', self.__field_slot, None) 
6271          yield ('eventname', self.__field_eventname, None) 
6272          yield ('pad1', self.__field_pad1, None) 
6273          yield ('eventname_len', self.__field_eventname_len, None) 
6274          yield ('start', self.__field_start, "# seconds since Jan 1, 1980 approximately") 
6275          yield ('end', self.__field_end, None) 
6276          yield ('location', self.__field_location, None) 
6277          yield ('pad2', self.__field_pad2, None) 
6278          yield ('location_len', self.__field_location_len, None) 
6279          yield ('alarmdiff', self.__field_alarmdiff, "Displayed alarm time") 
6280          yield ('period', self.__field_period, "No, Daily, Weekly, Monthly, Yearly") 
6281          yield ('dom', self.__field_dom, "Day of month for the event") 
6282          yield ('timestamp', self.__field_timestamp, None) 
6283          yield ('pad3', self.__field_pad3, None) 
6284          yield ('serial', self.__field_serial, "Some kind of serial number") 
6285          yield ('pad4', self.__field_pad4, None) 
6286          yield ('ringtone', self.__field_ringtone, None) 
6287   
6288   
6289   
6290   
6291 -class eventresponse(BaseProtogenClass): 
6292      __fields=['header', 'entry', 'pad'] 
6293   
6294 -    def __init__(self, *args, **kwargs): 
6295          dict={} 
6296          # What was supplied to this function 
6297          dict.update(kwargs) 
6298          # Parent constructor 
6299          super(eventresponse,self).__init__(**dict) 
6300          if self.__class__ is eventresponse: 
6301              self._update(args,dict) 
6302   
6303   
6304 -    def getfields(self): 
6305          return self.__fields 
6306   
6307   
6308 -    def _update(self, args, kwargs): 
6309          super(eventresponse,self)._update(args,kwargs) 
6310          keys=kwargs.keys() 
6311          for key in keys: 
6312              if key in self.__fields: 
6313                  setattr(self, key, kwargs[key]) 
6314                  del kwargs[key] 
6315          # Were any unrecognized kwargs passed in? 
6316          if __debug__: 
6317              self._complainaboutunusedargs(eventresponse,kwargs) 
6318          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
6319          # Make all P fields that haven't already been constructed 
6320   
6321   
6322 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
6323          'Writes this packet to the supplied buffer' 
6324          self._bufferstartoffset=buf.getcurrentoffset() 
6325          self.__field_header.writetobuffer(buf) 
6326          self.__field_entry.writetobuffer(buf) 
6327          self.__field_pad.writetobuffer(buf) 
6328          self._bufferendoffset=buf.getcurrentoffset() 
6329          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
6330   
6331   
6332 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
6333          'Reads this packet from the supplied buffer' 
6334          self._bufferstartoffset=buf.getcurrentoffset() 
6335          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
6336          self.__field_header=qcpheader() 
6337          self.__field_header.readfrombuffer(buf) 
6338          self.__field_entry=evententry() 
6339          self.__field_entry.readfrombuffer(buf) 
6340          self.__field_pad=UNKNOWN() 
6341          self.__field_pad.readfrombuffer(buf) 
6342          self._bufferendoffset=buf.getcurrentoffset() 
6343   
6344   
6345 -    def __getfield_header(self): 
6346          return self.__field_header.getvalue() 
6347   
6348 -    def __setfield_header(self, value): 
6349          if isinstance(value,qcpheader): 
6350              self.__field_header=value 
6351          else: 
6352              self.__field_header=qcpheader(value,) 
6353   
6354 -    def __delfield_header(self): del self.__field_header 
6355   
6356      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
6357   
6358 -    def __getfield_entry(self): 
6359          return self.__field_entry.getvalue() 
6360   
6361 -    def __setfield_entry(self, value): 
6362          if isinstance(value,evententry): 
6363              self.__field_entry=value 
6364          else: 
6365              self.__field_entry=evententry(value,) 
6366   
6367 -    def __delfield_entry(self): del self.__field_entry 
6368   
6369      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
6370   
6371 -    def __getfield_pad(self): 
6372          return self.__field_pad.getvalue() 
6373   
6374 -    def __setfield_pad(self, value): 
6375          if isinstance(value,UNKNOWN): 
6376              self.__field_pad=value 
6377          else: 
6378              self.__field_pad=UNKNOWN(value,) 
6379   
6380 -    def __delfield_pad(self): del self.__field_pad 
6381   
6382      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
6383   
6384 -    def iscontainer(self): 
6385          return True 
6386   
6387 -    def containerelements(self): 
6388          yield ('header', self.__field_header, None) 
6389          yield ('entry', self.__field_entry, None) 
6390          yield ('pad', self.__field_pad, None) 
6391   
6392   
6393   
6394   
6395 -class eventupdaterequest(BaseProtogenClass): 
6396      __fields=['header', 'entry', 'pad'] 
6397   
6398 -    def __init__(self, *args, **kwargs): 
6399          dict={} 
6400          # What was supplied to this function 
6401          dict.update(kwargs) 
6402          # Parent constructor 
6403          super(eventupdaterequest,self).__init__(**dict) 
6404          if self.__class__ is eventupdaterequest: 
6405              self._update(args,dict) 
6406   
6407   
6408 -    def getfields(self): 
6409          return self.__fields 
6410   
6411   
6412 -    def _update(self, args, kwargs): 
6413          super(eventupdaterequest,self)._update(args,kwargs) 
6414          keys=kwargs.keys() 
6415          for key in keys: 
6416              if key in self.__fields: 
6417                  setattr(self, key, kwargs[key]) 
6418                  del kwargs[key] 
6419          # Were any unrecognized kwargs passed in? 
6420          if __debug__: 
6421              self._complainaboutunusedargs(eventupdaterequest,kwargs) 
6422          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
6423          # Make all P fields that haven't already been constructed 
6424   
6425   
6426 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
6427          'Writes this packet to the supplied buffer' 
6428          self._bufferstartoffset=buf.getcurrentoffset() 
6429          try: self.__field_header 
6430          except: 
6431              self.__field_header=qcpwriteheader(**{'packettype': 0x0c, 'command':0x23}) 
6432          self.__field_header.writetobuffer(buf) 
6433          self.__field_entry.writetobuffer(buf) 
6434          try: self.__field_pad 
6435          except: 
6436              self.__field_pad=UNKNOWN(**{'sizeinbytes': 56}) 
6437          self.__field_pad.writetobuffer(buf) 
6438          self._bufferendoffset=buf.getcurrentoffset() 
6439          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
6440   
6441   
6442 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
6443          'Reads this packet from the supplied buffer' 
6444          self._bufferstartoffset=buf.getcurrentoffset() 
6445          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
6446          self.__field_header=qcpwriteheader(**{'packettype': 0x0c, 'command':0x23}) 
6447          self.__field_header.readfrombuffer(buf) 
6448          self.__field_entry=evententry() 
6449          self.__field_entry.readfrombuffer(buf) 
6450          self.__field_pad=UNKNOWN(**{'sizeinbytes': 56}) 
6451          self.__field_pad.readfrombuffer(buf) 
6452          self._bufferendoffset=buf.getcurrentoffset() 
6453   
6454   
6455 -    def __getfield_header(self): 
6456          try: self.__field_header 
6457          except: 
6458              self.__field_header=qcpwriteheader(**{'packettype': 0x0c, 'command':0x23}) 
6459          return self.__field_header.getvalue() 
6460   
6461 -    def __setfield_header(self, value): 
6462          if isinstance(value,qcpwriteheader): 
6463              self.__field_header=value 
6464          else: 
6465              self.__field_header=qcpwriteheader(value,**{'packettype': 0x0c, 'command':0x23}) 
6466   
6467 -    def __delfield_header(self): del self.__field_header 
6468   
6469      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
6470   
6471 -    def __getfield_entry(self): 
6472          return self.__field_entry.getvalue() 
6473   
6474 -    def __setfield_entry(self, value): 
6475          if isinstance(value,evententry): 
6476              self.__field_entry=value 
6477          else: 
6478              self.__field_entry=evententry(value,) 
6479   
6480 -    def __delfield_entry(self): del self.__field_entry 
6481   
6482      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
6483   
6484 -    def __getfield_pad(self): 
6485          try: self.__field_pad 
6486          except: 
6487              self.__field_pad=UNKNOWN(**{'sizeinbytes': 56}) 
6488          return self.__field_pad.getvalue() 
6489   
6490 -    def __setfield_pad(self, value): 
6491          if isinstance(value,UNKNOWN): 
6492              self.__field_pad=value 
6493          else: 
6494              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 56}) 
6495   
6496 -    def __delfield_pad(self): del self.__field_pad 
6497   
6498      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
6499   
6500 -    def iscontainer(self): 
6501          return True 
6502   
6503 -    def containerelements(self): 
6504          yield ('header', self.__field_header, None) 
6505          yield ('entry', self.__field_entry, None) 
6506          yield ('pad', self.__field_pad, None) 
6507   
6508   
6509   
6510   
6511 -class messagesententry(BaseProtogenClass): 
6512      __fields=['slot', 'read', 'counter', 'pad1', 'dunno1', 'dunno2', 'dunno3', 'pad2', 'dunno4', 'dunno5', 'pad3', 'message_len', 'message', 'pad4', 'pad5', 'year', 'month', 'day', 'hour', 'minute', 'second', 'callback_len', 'callback', 'phonenum_len', 'phonenum', 'dunno6', 'priority', 'pad6', 'dunno7', 'dunno8'] 
6513   
6514 -    def __init__(self, *args, **kwargs): 
6515          dict={} 
6516          # What was supplied to this function 
6517          dict.update(kwargs) 
6518          # Parent constructor 
6519          super(messagesententry,self).__init__(**dict) 
6520          if self.__class__ is messagesententry: 
6521              self._update(args,dict) 
6522   
6523   
6524 -    def getfields(self): 
6525          return self.__fields 
6526   
6527   
6528 -    def _update(self, args, kwargs): 
6529          super(messagesententry,self)._update(args,kwargs) 
6530          keys=kwargs.keys() 
6531          for key in keys: 
6532              if key in self.__fields: 
6533                  setattr(self, key, kwargs[key]) 
6534                  del kwargs[key] 
6535          # Were any unrecognized kwargs passed in? 
6536          if __debug__: 
6537              self._complainaboutunusedargs(messagesententry,kwargs) 
6538          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
6539          # Make all P fields that haven't already been constructed 
6540   
6541   
6542 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
6543          'Writes this packet to the supplied buffer' 
6544          self._bufferstartoffset=buf.getcurrentoffset() 
6545          self.__field_slot.writetobuffer(buf) 
6546          self.__field_read.writetobuffer(buf) 
6547          self.__field_counter.writetobuffer(buf) 
6548          self.__field_pad1.writetobuffer(buf) 
6549          self.__field_dunno1.writetobuffer(buf) 
6550          self.__field_dunno2.writetobuffer(buf) 
6551          self.__field_dunno3.writetobuffer(buf) 
6552          self.__field_pad2.writetobuffer(buf) 
6553          self.__field_dunno4.writetobuffer(buf) 
6554          self.__field_dunno5.writetobuffer(buf) 
6555          self.__field_pad3.writetobuffer(buf) 
6556          self.__field_message_len.writetobuffer(buf) 
6557          self.__field_message.writetobuffer(buf) 
6558          self.__field_pad4.writetobuffer(buf) 
6559          self.__field_pad5.writetobuffer(buf) 
6560          self.__field_year.writetobuffer(buf) 
6561          self.__field_month.writetobuffer(buf) 
6562          self.__field_day.writetobuffer(buf) 
6563          self.__field_hour.writetobuffer(buf) 
6564          self.__field_minute.writetobuffer(buf) 
6565          self.__field_second.writetobuffer(buf) 
6566          self.__field_callback_len.writetobuffer(buf) 
6567          self.__field_callback.writetobuffer(buf) 
6568          self.__field_phonenum_len.writetobuffer(buf) 
6569          self.__field_phonenum.writetobuffer(buf) 
6570          self.__field_dunno6.writetobuffer(buf) 
6571          self.__field_priority.writetobuffer(buf) 
6572          self.__field_pad6.writetobuffer(buf) 
6573          self.__field_dunno7.writetobuffer(buf) 
6574          self.__field_dunno8.writetobuffer(buf) 
6575          self._bufferendoffset=buf.getcurrentoffset() 
6576          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
6577   
6578   
6579 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
6580          'Reads this packet from the supplied buffer' 
6581          self._bufferstartoffset=buf.getcurrentoffset() 
6582          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
6583          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
6584          self.__field_slot.readfrombuffer(buf) 
6585          self.__field_read=UINT(**{'sizeinbytes': 1}) 
6586          self.__field_read.readfrombuffer(buf) 
6587          self.__field_counter=UINT(**{'sizeinbytes': 1}) 
6588          self.__field_counter.readfrombuffer(buf) 
6589          self.__field_pad1=UNKNOWN(**{'sizeinbytes': 3}) 
6590          self.__field_pad1.readfrombuffer(buf) 
6591          self.__field_dunno1=UINT(**{'sizeinbytes': 1}) 
6592          self.__field_dunno1.readfrombuffer(buf) 
6593          self.__field_dunno2=UINT(**{'sizeinbytes': 1}) 
6594          self.__field_dunno2.readfrombuffer(buf) 
6595          self.__field_dunno3=UINT(**{'sizeinbytes': 1}) 
6596          self.__field_dunno3.readfrombuffer(buf) 
6597          self.__field_pad2=UNKNOWN(**{'sizeinbytes': 1}) 
6598          self.__field_pad2.readfrombuffer(buf) 
6599          self.__field_dunno4=UINT(**{'sizeinbytes': 1}) 
6600          self.__field_dunno4.readfrombuffer(buf) 
6601          self.__field_dunno5=UINT(**{'sizeinbytes': 1}) 
6602          self.__field_dunno5.readfrombuffer(buf) 
6603          self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1}) 
6604          self.__field_pad3.readfrombuffer(buf) 
6605          self.__field_message_len=UINT(**{'sizeinbytes': 1}) 
6606          self.__field_message_len.readfrombuffer(buf) 
6607          self.__field_message=USTRING(**{'sizeinbytes': 255}) 
6608          self.__field_message.readfrombuffer(buf) 
6609          self.__field_pad4=UNKNOWN(**{'sizeinbytes': 1}) 
6610          self.__field_pad4.readfrombuffer(buf) 
6611          self.__field_pad5=UINT(**{'sizeinbytes': 1}) 
6612          self.__field_pad5.readfrombuffer(buf) 
6613          self.__field_year=UINT(**{'sizeinbytes': 1}) 
6614          self.__field_year.readfrombuffer(buf) 
6615          self.__field_month=UINT(**{'sizeinbytes': 1}) 
6616          self.__field_month.readfrombuffer(buf) 
6617          self.__field_day=UINT(**{'sizeinbytes': 1}) 
6618          self.__field_day.readfrombuffer(buf) 
6619          self.__field_hour=UINT(**{'sizeinbytes': 1}) 
6620          self.__field_hour.readfrombuffer(buf) 
6621          self.__field_minute=UINT(**{'sizeinbytes': 1}) 
6622          self.__field_minute.readfrombuffer(buf) 
6623          self.__field_second=UINT(**{'sizeinbytes': 1}) 
6624          self.__field_second.readfrombuffer(buf) 
6625          self.__field_callback_len=UINT(**{'sizeinbytes': 1}) 
6626          self.__field_callback_len.readfrombuffer(buf) 
6627          self.__field_callback=USTRING(**{'sizeinbytes': 34}) 
6628          self.__field_callback.readfrombuffer(buf) 
6629          self.__field_phonenum_len=UINT(**{'sizeinbytes': 1}) 
6630          self.__field_phonenum_len.readfrombuffer(buf) 
6631          self.__field_phonenum=USTRING(**{'sizeinbytes': 36}) 
6632          self.__field_phonenum.readfrombuffer(buf) 
6633          self.__field_dunno6=UINT(**{'sizeinbytes': 1}) 
6634          self.__field_dunno6.readfrombuffer(buf) 
6635          self.__field_priority=UINT(**{'sizeinbytes': 1}) 
6636          self.__field_priority.readfrombuffer(buf) 
6637          self.__field_pad6=UNKNOWN(**{'sizeinbytes': 3}) 
6638          self.__field_pad6.readfrombuffer(buf) 
6639          self.__field_dunno7=UINT(**{'sizeinbytes': 1}) 
6640          self.__field_dunno7.readfrombuffer(buf) 
6641          self.__field_dunno8=UINT(**{'sizeinbytes': 1}) 
6642          self.__field_dunno8.readfrombuffer(buf) 
6643          self._bufferendoffset=buf.getcurrentoffset() 
6644   
6645   
6646 -    def __getfield_slot(self): 
6647          return self.__field_slot.getvalue() 
6648   
6649 -    def __setfield_slot(self, value): 
6650          if isinstance(value,UINT): 
6651              self.__field_slot=value 
6652          else: 
6653              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
6654   
6655 -    def __delfield_slot(self): del self.__field_slot 
6656   
6657      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
6658   
6659 -    def __getfield_read(self): 
6660          return self.__field_read.getvalue() 
6661   
6662 -    def __setfield_read(self, value): 
6663          if isinstance(value,UINT): 
6664              self.__field_read=value 
6665          else: 
6666              self.__field_read=UINT(value,**{'sizeinbytes': 1}) 
6667   
6668 -    def __delfield_read(self): del self.__field_read 
6669   
6670      read=property(__getfield_read, __setfield_read, __delfield_read, None) 
6671   
6672 -    def __getfield_counter(self): 
6673          return self.__field_counter.getvalue() 
6674   
6675 -    def __setfield_counter(self, value): 
6676          if isinstance(value,UINT): 
6677              self.__field_counter=value 
6678          else: 
6679              self.__field_counter=UINT(value,**{'sizeinbytes': 1}) 
6680   
6681 -    def __delfield_counter(self): del self.__field_counter 
6682   
6683      counter=property(__getfield_counter, __setfield_counter, __delfield_counter, None) 
6684   
6685 -    def __getfield_pad1(self): 
6686          return self.__field_pad1.getvalue() 
6687   
6688 -    def __setfield_pad1(self, value): 
6689          if isinstance(value,UNKNOWN): 
6690              self.__field_pad1=value 
6691          else: 
6692              self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 3}) 
6693   
6694 -    def __delfield_pad1(self): del self.__field_pad1 
6695   
6696      pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None) 
6697   
6698 -    def __getfield_dunno1(self): 
6699          return self.__field_dunno1.getvalue() 
6700   
6701 -    def __setfield_dunno1(self, value): 
6702          if isinstance(value,UINT): 
6703              self.__field_dunno1=value 
6704          else: 
6705              self.__field_dunno1=UINT(value,**{'sizeinbytes': 1}) 
6706   
6707 -    def __delfield_dunno1(self): del self.__field_dunno1 
6708   
6709      dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None) 
6710   
6711 -    def __getfield_dunno2(self): 
6712          return self.__field_dunno2.getvalue() 
6713   
6714 -    def __setfield_dunno2(self, value): 
6715          if isinstance(value,UINT): 
6716              self.__field_dunno2=value 
6717          else: 
6718              self.__field_dunno2=UINT(value,**{'sizeinbytes': 1}) 
6719   
6720 -    def __delfield_dunno2(self): del self.__field_dunno2 
6721   
6722      dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None) 
6723   
6724 -    def __getfield_dunno3(self): 
6725          return self.__field_dunno3.getvalue() 
6726   
6727 -    def __setfield_dunno3(self, value): 
6728          if isinstance(value,UINT): 
6729              self.__field_dunno3=value 
6730          else: 
6731              self.__field_dunno3=UINT(value,**{'sizeinbytes': 1}) 
6732   
6733 -    def __delfield_dunno3(self): del self.__field_dunno3 
6734   
6735      dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None) 
6736   
6737 -    def __getfield_pad2(self): 
6738          return self.__field_pad2.getvalue() 
6739   
6740 -    def __setfield_pad2(self, value): 
6741          if isinstance(value,UNKNOWN): 
6742              self.__field_pad2=value 
6743          else: 
6744              self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 1}) 
6745   
6746 -    def __delfield_pad2(self): del self.__field_pad2 
6747   
6748      pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None) 
6749   
6750 -    def __getfield_dunno4(self): 
6751          return self.__field_dunno4.getvalue() 
6752   
6753 -    def __setfield_dunno4(self, value): 
6754          if isinstance(value,UINT): 
6755              self.__field_dunno4=value 
6756          else: 
6757              self.__field_dunno4=UINT(value,**{'sizeinbytes': 1}) 
6758   
6759 -    def __delfield_dunno4(self): del self.__field_dunno4 
6760   
6761      dunno4=property(__getfield_dunno4, __setfield_dunno4, __delfield_dunno4, None) 
6762   
6763 -    def __getfield_dunno5(self): 
6764          return self.__field_dunno5.getvalue() 
6765   
6766 -    def __setfield_dunno5(self, value): 
6767          if isinstance(value,UINT): 
6768              self.__field_dunno5=value 
6769          else: 
6770              self.__field_dunno5=UINT(value,**{'sizeinbytes': 1}) 
6771   
6772 -    def __delfield_dunno5(self): del self.__field_dunno5 
6773   
6774      dunno5=property(__getfield_dunno5, __setfield_dunno5, __delfield_dunno5, None) 
6775   
6776 -    def __getfield_pad3(self): 
6777          return self.__field_pad3.getvalue() 
6778   
6779 -    def __setfield_pad3(self, value): 
6780          if isinstance(value,UNKNOWN): 
6781              self.__field_pad3=value 
6782          else: 
6783              self.__field_pad3=UNKNOWN(value,**{'sizeinbytes': 1}) 
6784   
6785 -    def __delfield_pad3(self): del self.__field_pad3 
6786   
6787      pad3=property(__getfield_pad3, __setfield_pad3, __delfield_pad3, None) 
6788   
6789 -    def __getfield_message_len(self): 
6790          return self.__field_message_len.getvalue() 
6791   
6792 -    def __setfield_message_len(self, value): 
6793          if isinstance(value,UINT): 
6794              self.__field_message_len=value 
6795          else: 
6796              self.__field_message_len=UINT(value,**{'sizeinbytes': 1}) 
6797   
6798 -    def __delfield_message_len(self): del self.__field_message_len 
6799   
6800      message_len=property(__getfield_message_len, __setfield_message_len, __delfield_message_len, None) 
6801   
6802 -    def __getfield_message(self): 
6803          return self.__field_message.getvalue() 
6804   
6805 -    def __setfield_message(self, value): 
6806          if isinstance(value,USTRING): 
6807              self.__field_message=value 
6808          else: 
6809              self.__field_message=USTRING(value,**{'sizeinbytes': 255}) 
6810   
6811 -    def __delfield_message(self): del self.__field_message 
6812   
6813      message=property(__getfield_message, __setfield_message, __delfield_message, "Text of the notification") 
6814   
6815 -    def __getfield_pad4(self): 
6816          return self.__field_pad4.getvalue() 
6817   
6818 -    def __setfield_pad4(self, value): 
6819          if isinstance(value,UNKNOWN): 
6820              self.__field_pad4=value 
6821          else: 
6822              self.__field_pad4=UNKNOWN(value,**{'sizeinbytes': 1}) 
6823   
6824 -    def __delfield_pad4(self): del self.__field_pad4 
6825   
6826      pad4=property(__getfield_pad4, __setfield_pad4, __delfield_pad4, None) 
6827   
6828 -    def __getfield_pad5(self): 
6829          return self.__field_pad5.getvalue() 
6830   
6831 -    def __setfield_pad5(self, value): 
6832          if isinstance(value,UINT): 
6833              self.__field_pad5=value 
6834          else: 
6835              self.__field_pad5=UINT(value,**{'sizeinbytes': 1}) 
6836   
6837 -    def __delfield_pad5(self): del self.__field_pad5 
6838   
6839      pad5=property(__getfield_pad5, __setfield_pad5, __delfield_pad5, None) 
6840   
6841 -    def __getfield_year(self): 
6842          return self.__field_year.getvalue() 
6843   
6844 -    def __setfield_year(self, value): 
6845          if isinstance(value,UINT): 
6846              self.__field_year=value 
6847          else: 
6848              self.__field_year=UINT(value,**{'sizeinbytes': 1}) 
6849   
6850 -    def __delfield_year(self): del self.__field_year 
6851   
6852      year=property(__getfield_year, __setfield_year, __delfield_year, None) 
6853   
6854 -    def __getfield_month(self): 
6855          return self.__field_month.getvalue() 
6856   
6857 -    def __setfield_month(self, value): 
6858          if isinstance(value,UINT): 
6859              self.__field_month=value 
6860          else: 
6861              self.__field_month=UINT(value,**{'sizeinbytes': 1}) 
6862   
6863 -    def __delfield_month(self): del self.__field_month 
6864   
6865      month=property(__getfield_month, __setfield_month, __delfield_month, None) 
6866   
6867 -    def __getfield_day(self): 
6868          return self.__field_day.getvalue() 
6869   
6870 -    def __setfield_day(self, value): 
6871          if isinstance(value,UINT): 
6872              self.__field_day=value 
6873          else: 
6874              self.__field_day=UINT(value,**{'sizeinbytes': 1}) 
6875   
6876 -    def __delfield_day(self): del self.__field_day 
6877   
6878      day=property(__getfield_day, __setfield_day, __delfield_day, None) 
6879   
6880 -    def __getfield_hour(self): 
6881          return self.__field_hour.getvalue() 
6882   
6883 -    def __setfield_hour(self, value): 
6884          if isinstance(value,UINT): 
6885              self.__field_hour=value 
6886          else: 
6887              self.__field_hour=UINT(value,**{'sizeinbytes': 1}) 
6888   
6889 -    def __delfield_hour(self): del self.__field_hour 
6890   
6891      hour=property(__getfield_hour, __setfield_hour, __delfield_hour, None) 
6892   
6893 -    def __getfield_minute(self): 
6894          return self.__field_minute.getvalue() 
6895   
6896 -    def __setfield_minute(self, value): 
6897          if isinstance(value,UINT): 
6898              self.__field_minute=value 
6899          else: 
6900              self.__field_minute=UINT(value,**{'sizeinbytes': 1}) 
6901   
6902 -    def __delfield_minute(self): del self.__field_minute 
6903   
6904      minute=property(__getfield_minute, __setfield_minute, __delfield_minute, None) 
6905   
6906 -    def __getfield_second(self): 
6907          return self.__field_second.getvalue() 
6908   
6909 -    def __setfield_second(self, value): 
6910          if isinstance(value,UINT): 
6911              self.__field_second=value 
6912          else: 
6913              self.__field_second=UINT(value,**{'sizeinbytes': 1}) 
6914   
6915 -    def __delfield_second(self): del self.__field_second 
6916   
6917      second=property(__getfield_second, __setfield_second, __delfield_second, None) 
6918   
6919 -    def __getfield_callback_len(self): 
6920          return self.__field_callback_len.getvalue() 
6921   
6922 -    def __setfield_callback_len(self, value): 
6923          if isinstance(value,UINT): 
6924              self.__field_callback_len=value 
6925          else: 
6926              self.__field_callback_len=UINT(value,**{'sizeinbytes': 1}) 
6927   
6928 -    def __delfield_callback_len(self): del self.__field_callback_len 
6929   
6930      callback_len=property(__getfield_callback_len, __setfield_callback_len, __delfield_callback_len, None) 
6931   
6932 -    def __getfield_callback(self): 
6933          return self.__field_callback.getvalue() 
6934   
6935 -    def __setfield_callback(self, value): 
6936          if isinstance(value,USTRING): 
6937              self.__field_callback=value 
6938          else: 
6939              self.__field_callback=USTRING(value,**{'sizeinbytes': 34}) 
6940   
6941 -    def __delfield_callback(self): del self.__field_callback 
6942   
6943      callback=property(__getfield_callback, __setfield_callback, __delfield_callback, None) 
6944   
6945 -    def __getfield_phonenum_len(self): 
6946          return self.__field_phonenum_len.getvalue() 
6947   
6948 -    def __setfield_phonenum_len(self, value): 
6949          if isinstance(value,UINT): 
6950              self.__field_phonenum_len=value 
6951          else: 
6952              self.__field_phonenum_len=UINT(value,**{'sizeinbytes': 1}) 
6953   
6954 -    def __delfield_phonenum_len(self): del self.__field_phonenum_len 
6955   
6956      phonenum_len=property(__getfield_phonenum_len, __setfield_phonenum_len, __delfield_phonenum_len, None) 
6957   
6958 -    def __getfield_phonenum(self): 
6959          return self.__field_phonenum.getvalue() 
6960   
6961 -    def __setfield_phonenum(self, value): 
6962          if isinstance(value,USTRING): 
6963              self.__field_phonenum=value 
6964          else: 
6965              self.__field_phonenum=USTRING(value,**{'sizeinbytes': 36}) 
6966   
6967 -    def __delfield_phonenum(self): del self.__field_phonenum 
6968   
6969      phonenum=property(__getfield_phonenum, __setfield_phonenum, __delfield_phonenum, None) 
6970   
6971 -    def __getfield_dunno6(self): 
6972          return self.__field_dunno6.getvalue() 
6973   
6974 -    def __setfield_dunno6(self, value): 
6975          if isinstance(value,UINT): 
6976              self.__field_dunno6=value 
6977          else: 
6978              self.__field_dunno6=UINT(value,**{'sizeinbytes': 1}) 
6979   
6980 -    def __delfield_dunno6(self): del self.__field_dunno6 
6981   
6982      dunno6=property(__getfield_dunno6, __setfield_dunno6, __delfield_dunno6, None) 
6983   
6984 -    def __getfield_priority(self): 
6985          return self.__field_priority.getvalue() 
6986   
6987 -    def __setfield_priority(self, value): 
6988          if isinstance(value,UINT): 
6989              self.__field_priority=value 
6990          else: 
6991              self.__field_priority=UINT(value,**{'sizeinbytes': 1}) 
6992   
6993 -    def __delfield_priority(self): del self.__field_priority 
6994   
6995      priority=property(__getfield_priority, __setfield_priority, __delfield_priority, None) 
6996   
6997 -    def __getfield_pad6(self): 
6998          return self.__field_pad6.getvalue() 
6999   
7000 -    def __setfield_pad6(self, value): 
7001          if isinstance(value,UNKNOWN): 
7002              self.__field_pad6=value 
7003          else: 
7004              self.__field_pad6=UNKNOWN(value,**{'sizeinbytes': 3}) 
7005   
7006 -    def __delfield_pad6(self): del self.__field_pad6 
7007   
7008      pad6=property(__getfield_pad6, __setfield_pad6, __delfield_pad6, None) 
7009   
7010 -    def __getfield_dunno7(self): 
7011          return self.__field_dunno7.getvalue() 
7012   
7013 -    def __setfield_dunno7(self, value): 
7014          if isinstance(value,UINT): 
7015              self.__field_dunno7=value 
7016          else: 
7017              self.__field_dunno7=UINT(value,**{'sizeinbytes': 1}) 
7018   
7019 -    def __delfield_dunno7(self): del self.__field_dunno7 
7020   
7021      dunno7=property(__getfield_dunno7, __setfield_dunno7, __delfield_dunno7, None) 
7022   
7023 -    def __getfield_dunno8(self): 
7024          return self.__field_dunno8.getvalue() 
7025   
7026 -    def __setfield_dunno8(self, value): 
7027          if isinstance(value,UINT): 
7028              self.__field_dunno8=value 
7029          else: 
7030              self.__field_dunno8=UINT(value,**{'sizeinbytes': 1}) 
7031   
7032 -    def __delfield_dunno8(self): del self.__field_dunno8 
7033   
7034      dunno8=property(__getfield_dunno8, __setfield_dunno8, __delfield_dunno8, None) 
7035   
7036 -    def iscontainer(self): 
7037          return True 
7038   
7039 -    def containerelements(self): 
7040          yield ('slot', self.__field_slot, None) 
7041          yield ('read', self.__field_read, None) 
7042          yield ('counter', self.__field_counter, None) 
7043          yield ('pad1', self.__field_pad1, None) 
7044          yield ('dunno1', self.__field_dunno1, None) 
7045          yield ('dunno2', self.__field_dunno2, None) 
7046          yield ('dunno3', self.__field_dunno3, None) 
7047          yield ('pad2', self.__field_pad2, None) 
7048          yield ('dunno4', self.__field_dunno4, None) 
7049          yield ('dunno5', self.__field_dunno5, None) 
7050          yield ('pad3', self.__field_pad3, None) 
7051          yield ('message_len', self.__field_message_len, None) 
7052          yield ('message', self.__field_message, "Text of the notification") 
7053          yield ('pad4', self.__field_pad4, None) 
7054          yield ('pad5', self.__field_pad5, None) 
7055          yield ('year', self.__field_year, None) 
7056          yield ('month', self.__field_month, None) 
7057          yield ('day', self.__field_day, None) 
7058          yield ('hour', self.__field_hour, None) 
7059          yield ('minute', self.__field_minute, None) 
7060          yield ('second', self.__field_second, None) 
7061          yield ('callback_len', self.__field_callback_len, None) 
7062          yield ('callback', self.__field_callback, None) 
7063          yield ('phonenum_len', self.__field_phonenum_len, None) 
7064          yield ('phonenum', self.__field_phonenum, None) 
7065          yield ('dunno6', self.__field_dunno6, None) 
7066          yield ('priority', self.__field_priority, None) 
7067          yield ('pad6', self.__field_pad6, None) 
7068          yield ('dunno7', self.__field_dunno7, None) 
7069          yield ('dunno8', self.__field_dunno8, None) 
7070   
7071   
7072   
7073   
7074 -class messagesentresponse(BaseProtogenClass): 
7075      __fields=['header', 'entry', 'pad'] 
7076   
7077 -    def __init__(self, *args, **kwargs): 
7078          dict={} 
7079          # What was supplied to this function 
7080          dict.update(kwargs) 
7081          # Parent constructor 
7082          super(messagesentresponse,self).__init__(**dict) 
7083          if self.__class__ is messagesentresponse: 
7084              self._update(args,dict) 
7085   
7086   
7087 -    def getfields(self): 
7088          return self.__fields 
7089   
7090   
7091 -    def _update(self, args, kwargs): 
7092          super(messagesentresponse,self)._update(args,kwargs) 
7093          keys=kwargs.keys() 
7094          for key in keys: 
7095              if key in self.__fields: 
7096                  setattr(self, key, kwargs[key]) 
7097                  del kwargs[key] 
7098          # Were any unrecognized kwargs passed in? 
7099          if __debug__: 
7100              self._complainaboutunusedargs(messagesentresponse,kwargs) 
7101          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
7102          # Make all P fields that haven't already been constructed 
7103   
7104   
7105 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
7106          'Writes this packet to the supplied buffer' 
7107          self._bufferstartoffset=buf.getcurrentoffset() 
7108          self.__field_header.writetobuffer(buf) 
7109          self.__field_entry.writetobuffer(buf) 
7110          self.__field_pad.writetobuffer(buf) 
7111          self._bufferendoffset=buf.getcurrentoffset() 
7112          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
7113   
7114   
7115 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
7116          'Reads this packet from the supplied buffer' 
7117          self._bufferstartoffset=buf.getcurrentoffset() 
7118          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
7119          self.__field_header=sanyoheader() 
7120          self.__field_header.readfrombuffer(buf) 
7121          self.__field_entry=messagesententry() 
7122          self.__field_entry.readfrombuffer(buf) 
7123          self.__field_pad=UNKNOWN() 
7124          self.__field_pad.readfrombuffer(buf) 
7125          self._bufferendoffset=buf.getcurrentoffset() 
7126   
7127   
7128 -    def __getfield_header(self): 
7129          return self.__field_header.getvalue() 
7130   
7131 -    def __setfield_header(self, value): 
7132          if isinstance(value,sanyoheader): 
7133              self.__field_header=value 
7134          else: 
7135              self.__field_header=sanyoheader(value,) 
7136   
7137 -    def __delfield_header(self): del self.__field_header 
7138   
7139      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
7140   
7141 -    def __getfield_entry(self): 
7142          return self.__field_entry.getvalue() 
7143   
7144 -    def __setfield_entry(self, value): 
7145          if isinstance(value,messagesententry): 
7146              self.__field_entry=value 
7147          else: 
7148              self.__field_entry=messagesententry(value,) 
7149   
7150 -    def __delfield_entry(self): del self.__field_entry 
7151   
7152      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
7153   
7154 -    def __getfield_pad(self): 
7155          return self.__field_pad.getvalue() 
7156   
7157 -    def __setfield_pad(self, value): 
7158          if isinstance(value,UNKNOWN): 
7159              self.__field_pad=value 
7160          else: 
7161              self.__field_pad=UNKNOWN(value,) 
7162   
7163 -    def __delfield_pad(self): del self.__field_pad 
7164   
7165      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
7166   
7167 -    def iscontainer(self): 
7168          return True 
7169   
7170 -    def containerelements(self): 
7171          yield ('header', self.__field_header, None) 
7172          yield ('entry', self.__field_entry, None) 
7173          yield ('pad', self.__field_pad, None) 
7174