Source Code for Module phones.p_samsungspha620

   1  # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE 
   2   
   3  """Proposed descriptions of data usign AT commands""" 
   4   
   5  from prototypes import * 
   6  from p_samsung_packet import * 
   7   
   8  # We use LSB for all integer like fields in diagnostic mode 
   9  UINT=UINTlsb 
  10  BOOL=BOOLlsb 
  11  # 
  12   
  13  NUMPHONEBOOKENTRIES=300 
  14  NUMEMAILS=3 
  15  NUMPHONENUMBERS=6 
  16  MAXNUMBERLEN=32 
  17  NUMTODOENTRIES=9 
  18  NUMSMSENTRIES=94 
  19   
  20  NUMGROUPS=4 
  21   
  22  AMSREGISTRY="ams/AmsRegistry" 
  23  ENDTRANSACTION="ams/EndTransaction" 
  24  RINGERPREFIX="ams/Ringers/cnts" 
  25  WALLPAPERPREFIX="ams/Screen Savers/cnts" 
  26   
  27 -class pbentry(BaseProtogenClass): 
  28      __fields=['slot', 'uslot', 'group', 'ringtone', 'name', 'speeddial', 'dunno1', 'numbers', 'dunno3', 'dunno4', 'email', 'url', 'birthday', 'wallpaper', 'timestamp'] 
  29   
  30 -    def __init__(self, *args, **kwargs): 
  31          dict={} 
  32          # What was supplied to this function 
  33          dict.update(kwargs) 
  34          # Parent constructor 
  35          super(pbentry,self).__init__(**dict) 
  36          if self.__class__ is pbentry: 
  37              self._update(args,dict) 
  38   
  39   
  40 -    def getfields(self): 
  41          return self.__fields 
  42   
  43   
  44 -    def _update(self, args, kwargs): 
  45          super(pbentry,self)._update(args,kwargs) 
  46          keys=kwargs.keys() 
  47          for key in keys: 
  48              if key in self.__fields: 
  49                  setattr(self, key, kwargs[key]) 
  50                  del kwargs[key] 
  51          # Were any unrecognized kwargs passed in? 
  52          if __debug__: 
  53              self._complainaboutunusedargs(pbentry,kwargs) 
  54          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
  55          # Make all P fields that haven't already been constructed 
  56   
  57   
  58 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
  59          'Writes this packet to the supplied buffer' 
  60          self._bufferstartoffset=buf.getcurrentoffset() 
  61          self.__field_slot.writetobuffer(buf) 
  62          self.__field_uslot.writetobuffer(buf) 
  63          self.__field_group.writetobuffer(buf) 
  64          try: self.__field_ringtone 
  65          except: 
  66              self.__field_ringtone=CSVINT(**{'default': 20}) 
  67          self.__field_ringtone.writetobuffer(buf) 
  68          self.__field_name.writetobuffer(buf) 
  69          self.__field_speeddial.writetobuffer(buf) 
  70          try: self.__field_dunno1 
  71          except: 
  72              self.__field_dunno1=CSVINT(**{'default': 0}) 
  73          self.__field_dunno1.writetobuffer(buf) 
  74          try: self.__field_numbers 
  75          except: 
  76              self.__field_numbers=LIST(**{'length': NUMPHONENUMBERS, 'createdefault': True, 'elementclass': phonenumber}) 
  77          self.__field_numbers.writetobuffer(buf) 
  78          try: self.__field_dunno3 
  79          except: 
  80              self.__field_dunno3=CSVSTRING(**{'quotechar': None, 'default': ""}) 
  81          self.__field_dunno3.writetobuffer(buf) 
  82          try: self.__field_dunno4 
  83          except: 
  84              self.__field_dunno4=CSVSTRING(**{'quotechar': None, 'default': ""}) 
  85          self.__field_dunno4.writetobuffer(buf) 
  86          self.__field_email.writetobuffer(buf) 
  87          self.__field_url.writetobuffer(buf) 
  88          try: self.__field_birthday 
  89          except: 
  90              self.__field_birthday=CSVDATE(**{'default': ""}) 
  91          self.__field_birthday.writetobuffer(buf) 
  92          try: self.__field_wallpaper 
  93          except: 
  94              self.__field_wallpaper=CSVINT(**{'default': 20}) 
  95          self.__field_wallpaper.writetobuffer(buf) 
  96          try: self.__field_timestamp 
  97          except: 
  98              self.__field_timestamp=CSVTIME(**{'terminator': None, 'default': (1980,1,1,12,0,0)}) 
  99          self.__field_timestamp.writetobuffer(buf) 
 100          self._bufferendoffset=buf.getcurrentoffset() 
 101          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 102   
 103   
 104 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 105          'Reads this packet from the supplied buffer' 
 106          self._bufferstartoffset=buf.getcurrentoffset() 
 107          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 108          self.__field_slot=CSVINT() 
 109          self.__field_slot.readfrombuffer(buf) 
 110          self.__field_uslot=CSVINT() 
 111          self.__field_uslot.readfrombuffer(buf) 
 112          self.__field_group=CSVINT() 
 113          self.__field_group.readfrombuffer(buf) 
 114          self.__field_ringtone=CSVINT(**{'default': 20}) 
 115          self.__field_ringtone.readfrombuffer(buf) 
 116          self.__field_name=CSVSTRING() 
 117          self.__field_name.readfrombuffer(buf) 
 118          self.__field_speeddial=CSVINT() 
 119          self.__field_speeddial.readfrombuffer(buf) 
 120          self.__field_dunno1=CSVINT(**{'default': 0}) 
 121          self.__field_dunno1.readfrombuffer(buf) 
 122          self.__field_numbers=LIST(**{'length': NUMPHONENUMBERS, 'createdefault': True, 'elementclass': phonenumber}) 
 123          self.__field_numbers.readfrombuffer(buf) 
 124          self.__field_dunno3=CSVSTRING(**{'quotechar': None, 'default': ""}) 
 125          self.__field_dunno3.readfrombuffer(buf) 
 126          self.__field_dunno4=CSVSTRING(**{'quotechar': None, 'default': ""}) 
 127          self.__field_dunno4.readfrombuffer(buf) 
 128          self.__field_email=CSVSTRING() 
 129          self.__field_email.readfrombuffer(buf) 
 130          self.__field_url=CSVSTRING() 
 131          self.__field_url.readfrombuffer(buf) 
 132          self.__field_birthday=CSVDATE(**{'default': ""}) 
 133          self.__field_birthday.readfrombuffer(buf) 
 134          self.__field_wallpaper=CSVINT(**{'default': 20}) 
 135          self.__field_wallpaper.readfrombuffer(buf) 
 136          self.__field_timestamp=CSVTIME(**{'terminator': None, 'default': (1980,1,1,12,0,0)}) 
 137          self.__field_timestamp.readfrombuffer(buf) 
 138          self._bufferendoffset=buf.getcurrentoffset() 
 139   
 140   
 141 -    def __getfield_slot(self): 
 142          return self.__field_slot.getvalue() 
 143   
 144 -    def __setfield_slot(self, value): 
 145          if isinstance(value,CSVINT): 
 146              self.__field_slot=value 
 147          else: 
 148              self.__field_slot=CSVINT(value,) 
 149   
 150 -    def __delfield_slot(self): del self.__field_slot 
 151   
 152      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, "Internal Slot") 
 153   
 154 -    def __getfield_uslot(self): 
 155          return self.__field_uslot.getvalue() 
 156   
 157 -    def __setfield_uslot(self, value): 
 158          if isinstance(value,CSVINT): 
 159              self.__field_uslot=value 
 160          else: 
 161              self.__field_uslot=CSVINT(value,) 
 162   
 163 -    def __delfield_uslot(self): del self.__field_uslot 
 164   
 165      uslot=property(__getfield_uslot, __setfield_uslot, __delfield_uslot, "User Slot, Speed dial") 
 166   
 167 -    def __getfield_group(self): 
 168          return self.__field_group.getvalue() 
 169   
 170 -    def __setfield_group(self, value): 
 171          if isinstance(value,CSVINT): 
 172              self.__field_group=value 
 173          else: 
 174              self.__field_group=CSVINT(value,) 
 175   
 176 -    def __delfield_group(self): del self.__field_group 
 177   
 178      group=property(__getfield_group, __setfield_group, __delfield_group, None) 
 179   
 180 -    def __getfield_ringtone(self): 
 181          try: self.__field_ringtone 
 182          except: 
 183              self.__field_ringtone=CSVINT(**{'default': 20}) 
 184          return self.__field_ringtone.getvalue() 
 185   
 186 -    def __setfield_ringtone(self, value): 
 187          if isinstance(value,CSVINT): 
 188              self.__field_ringtone=value 
 189          else: 
 190              self.__field_ringtone=CSVINT(value,**{'default': 20}) 
 191   
 192 -    def __delfield_ringtone(self): del self.__field_ringtone 
 193   
 194      ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 
 195   
 196 -    def __getfield_name(self): 
 197          return self.__field_name.getvalue() 
 198   
 199 -    def __setfield_name(self, value): 
 200          if isinstance(value,CSVSTRING): 
 201              self.__field_name=value 
 202          else: 
 203              self.__field_name=CSVSTRING(value,) 
 204   
 205 -    def __delfield_name(self): del self.__field_name 
 206   
 207      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
 208   
 209 -    def __getfield_speeddial(self): 
 210          return self.__field_speeddial.getvalue() 
 211   
 212 -    def __setfield_speeddial(self, value): 
 213          if isinstance(value,CSVINT): 
 214              self.__field_speeddial=value 
 215          else: 
 216              self.__field_speeddial=CSVINT(value,) 
 217   
 218 -    def __delfield_speeddial(self): del self.__field_speeddial 
 219   
 220      speeddial=property(__getfield_speeddial, __setfield_speeddial, __delfield_speeddial, "Which phone number assigned to speed dial uslot") 
 221   
 222 -    def __getfield_dunno1(self): 
 223          try: self.__field_dunno1 
 224          except: 
 225              self.__field_dunno1=CSVINT(**{'default': 0}) 
 226          return self.__field_dunno1.getvalue() 
 227   
 228 -    def __setfield_dunno1(self, value): 
 229          if isinstance(value,CSVINT): 
 230              self.__field_dunno1=value 
 231          else: 
 232              self.__field_dunno1=CSVINT(value,**{'default': 0}) 
 233   
 234 -    def __delfield_dunno1(self): del self.__field_dunno1 
 235   
 236      dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None) 
 237   
 238 -    def __getfield_numbers(self): 
 239          try: self.__field_numbers 
 240          except: 
 241              self.__field_numbers=LIST(**{'length': NUMPHONENUMBERS, 'createdefault': True, 'elementclass': phonenumber}) 
 242          return self.__field_numbers.getvalue() 
 243   
 244 -    def __setfield_numbers(self, value): 
 245          if isinstance(value,LIST): 
 246              self.__field_numbers=value 
 247          else: 
 248              self.__field_numbers=LIST(value,**{'length': NUMPHONENUMBERS, 'createdefault': True, 'elementclass': phonenumber}) 
 249   
 250 -    def __delfield_numbers(self): del self.__field_numbers 
 251   
 252      numbers=property(__getfield_numbers, __setfield_numbers, __delfield_numbers, None) 
 253   
 254 -    def __getfield_dunno3(self): 
 255          try: self.__field_dunno3 
 256          except: 
 257              self.__field_dunno3=CSVSTRING(**{'quotechar': None, 'default': ""}) 
 258          return self.__field_dunno3.getvalue() 
 259   
 260 -    def __setfield_dunno3(self, value): 
 261          if isinstance(value,CSVSTRING): 
 262              self.__field_dunno3=value 
 263          else: 
 264              self.__field_dunno3=CSVSTRING(value,**{'quotechar': None, 'default': ""}) 
 265   
 266 -    def __delfield_dunno3(self): del self.__field_dunno3 
 267   
 268      dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None) 
 269   
 270 -    def __getfield_dunno4(self): 
 271          try: self.__field_dunno4 
 272          except: 
 273              self.__field_dunno4=CSVSTRING(**{'quotechar': None, 'default': ""}) 
 274          return self.__field_dunno4.getvalue() 
 275   
 276 -    def __setfield_dunno4(self, value): 
 277          if isinstance(value,CSVSTRING): 
 278              self.__field_dunno4=value 
 279          else: 
 280              self.__field_dunno4=CSVSTRING(value,**{'quotechar': None, 'default': ""}) 
 281   
 282 -    def __delfield_dunno4(self): del self.__field_dunno4 
 283   
 284      dunno4=property(__getfield_dunno4, __setfield_dunno4, __delfield_dunno4, None) 
 285   
 286 -    def __getfield_email(self): 
 287          return self.__field_email.getvalue() 
 288   
 289 -    def __setfield_email(self, value): 
 290          if isinstance(value,CSVSTRING): 
 291              self.__field_email=value 
 292          else: 
 293              self.__field_email=CSVSTRING(value,) 
 294   
 295 -    def __delfield_email(self): del self.__field_email 
 296   
 297      email=property(__getfield_email, __setfield_email, __delfield_email, None) 
 298   
 299 -    def __getfield_url(self): 
 300          return self.__field_url.getvalue() 
 301   
 302 -    def __setfield_url(self, value): 
 303          if isinstance(value,CSVSTRING): 
 304              self.__field_url=value 
 305          else: 
 306              self.__field_url=CSVSTRING(value,) 
 307   
 308 -    def __delfield_url(self): del self.__field_url 
 309   
 310      url=property(__getfield_url, __setfield_url, __delfield_url, None) 
 311   
 312 -    def __getfield_birthday(self): 
 313          try: self.__field_birthday 
 314          except: 
 315              self.__field_birthday=CSVDATE(**{'default': ""}) 
 316          return self.__field_birthday.getvalue() 
 317   
 318 -    def __setfield_birthday(self, value): 
 319          if isinstance(value,CSVDATE): 
 320              self.__field_birthday=value 
 321          else: 
 322              self.__field_birthday=CSVDATE(value,**{'default': ""}) 
 323   
 324 -    def __delfield_birthday(self): del self.__field_birthday 
 325   
 326      birthday=property(__getfield_birthday, __setfield_birthday, __delfield_birthday, None) 
 327   
 328 -    def __getfield_wallpaper(self): 
 329          try: self.__field_wallpaper 
 330          except: 
 331              self.__field_wallpaper=CSVINT(**{'default': 20}) 
 332          return self.__field_wallpaper.getvalue() 
 333   
 334 -    def __setfield_wallpaper(self, value): 
 335          if isinstance(value,CSVINT): 
 336              self.__field_wallpaper=value 
 337          else: 
 338              self.__field_wallpaper=CSVINT(value,**{'default': 20}) 
 339   
 340 -    def __delfield_wallpaper(self): del self.__field_wallpaper 
 341   
 342      wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None) 
 343   
 344 -    def __getfield_timestamp(self): 
 345          try: self.__field_timestamp 
 346          except: 
 347              self.__field_timestamp=CSVTIME(**{'terminator': None, 'default': (1980,1,1,12,0,0)}) 
 348          return self.__field_timestamp.getvalue() 
 349   
 350 -    def __setfield_timestamp(self, value): 
 351          if isinstance(value,CSVTIME): 
 352              self.__field_timestamp=value 
 353          else: 
 354              self.__field_timestamp=CSVTIME(value,**{'terminator': None, 'default': (1980,1,1,12,0,0)}) 
 355   
 356 -    def __delfield_timestamp(self): del self.__field_timestamp 
 357   
 358      timestamp=property(__getfield_timestamp, __setfield_timestamp, __delfield_timestamp, "Use terminator None for last item") 
 359   
 360 -    def iscontainer(self): 
 361          return True 
 362   
 363 -    def containerelements(self): 
 364          yield ('slot', self.__field_slot, "Internal Slot") 
 365          yield ('uslot', self.__field_uslot, "User Slot, Speed dial") 
 366          yield ('group', self.__field_group, None) 
 367          yield ('ringtone', self.__field_ringtone, None) 
 368          yield ('name', self.__field_name, None) 
 369          yield ('speeddial', self.__field_speeddial, "Which phone number assigned to speed dial uslot") 
 370          yield ('dunno1', self.__field_dunno1, None) 
 371          yield ('numbers', self.__field_numbers, None) 
 372          yield ('dunno3', self.__field_dunno3, None) 
 373          yield ('dunno4', self.__field_dunno4, None) 
 374          yield ('email', self.__field_email, None) 
 375          yield ('url', self.__field_url, None) 
 376          yield ('birthday', self.__field_birthday, None) 
 377          yield ('wallpaper', self.__field_wallpaper, None) 
 378          yield ('timestamp', self.__field_timestamp, "Use terminator None for last item") 
 379   
 380   
 381   
 382   
 383 -class phonebookslotresponse(BaseProtogenClass): 
 384      __fields=['command', 'entry'] 
 385   
 386 -    def __init__(self, *args, **kwargs): 
 387          dict={} 
 388          # What was supplied to this function 
 389          dict.update(kwargs) 
 390          # Parent constructor 
 391          super(phonebookslotresponse,self).__init__(**dict) 
 392          if self.__class__ is phonebookslotresponse: 
 393              self._update(args,dict) 
 394   
 395   
 396 -    def getfields(self): 
 397          return self.__fields 
 398   
 399   
 400 -    def _update(self, args, kwargs): 
 401          super(phonebookslotresponse,self)._update(args,kwargs) 
 402          keys=kwargs.keys() 
 403          for key in keys: 
 404              if key in self.__fields: 
 405                  setattr(self, key, kwargs[key]) 
 406                  del kwargs[key] 
 407          # Were any unrecognized kwargs passed in? 
 408          if __debug__: 
 409              self._complainaboutunusedargs(phonebookslotresponse,kwargs) 
 410          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 411          # Make all P fields that haven't already been constructed 
 412   
 413   
 414 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 415          'Writes this packet to the supplied buffer' 
 416          self._bufferstartoffset=buf.getcurrentoffset() 
 417          self.__field_command.writetobuffer(buf) 
 418          self.__field_entry.writetobuffer(buf) 
 419          self._bufferendoffset=buf.getcurrentoffset() 
 420          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 421   
 422   
 423 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 424          'Reads this packet from the supplied buffer' 
 425          self._bufferstartoffset=buf.getcurrentoffset() 
 426          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 427          self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': ord(' '), 'constant': '#PBOKR:'}) 
 428          self.__field_command.readfrombuffer(buf) 
 429          self.__field_entry=pbentry() 
 430          self.__field_entry.readfrombuffer(buf) 
 431          self._bufferendoffset=buf.getcurrentoffset() 
 432   
 433   
 434 -    def __getfield_command(self): 
 435          return self.__field_command.getvalue() 
 436   
 437 -    def __setfield_command(self, value): 
 438          if isinstance(value,CSVSTRING): 
 439              self.__field_command=value 
 440          else: 
 441              self.__field_command=CSVSTRING(value,**{'quotechar': None, 'terminator': ord(' '), 'constant': '#PBOKR:'}) 
 442   
 443 -    def __delfield_command(self): del self.__field_command 
 444   
 445      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
 446   
 447 -    def __getfield_entry(self): 
 448          return self.__field_entry.getvalue() 
 449   
 450 -    def __setfield_entry(self, value): 
 451          if isinstance(value,pbentry): 
 452              self.__field_entry=value 
 453          else: 
 454              self.__field_entry=pbentry(value,) 
 455   
 456 -    def __delfield_entry(self): del self.__field_entry 
 457   
 458      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
 459   
 460 -    def iscontainer(self): 
 461          return True 
 462   
 463 -    def containerelements(self): 
 464          yield ('command', self.__field_command, None) 
 465          yield ('entry', self.__field_entry, None) 
 466   
 467   
 468   
 469   
 470 -class phonebookslotupdaterequest(BaseProtogenClass): 
 471      __fields=['command', 'entry'] 
 472   
 473 -    def __init__(self, *args, **kwargs): 
 474          dict={} 
 475          # What was supplied to this function 
 476          dict.update(kwargs) 
 477          # Parent constructor 
 478          super(phonebookslotupdaterequest,self).__init__(**dict) 
 479          if self.__class__ is phonebookslotupdaterequest: 
 480              self._update(args,dict) 
 481   
 482   
 483 -    def getfields(self): 
 484          return self.__fields 
 485   
 486   
 487 -    def _update(self, args, kwargs): 
 488          super(phonebookslotupdaterequest,self)._update(args,kwargs) 
 489          keys=kwargs.keys() 
 490          for key in keys: 
 491              if key in self.__fields: 
 492                  setattr(self, key, kwargs[key]) 
 493                  del kwargs[key] 
 494          # Were any unrecognized kwargs passed in? 
 495          if __debug__: 
 496              self._complainaboutunusedargs(phonebookslotupdaterequest,kwargs) 
 497          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 498          # Make all P fields that haven't already been constructed 
 499   
 500   
 501 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 502          'Writes this packet to the supplied buffer' 
 503          self._bufferstartoffset=buf.getcurrentoffset() 
 504          try: self.__field_command 
 505          except: 
 506              self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PBOKW=0,'}) 
 507          self.__field_command.writetobuffer(buf) 
 508          self.__field_entry.writetobuffer(buf) 
 509          self._bufferendoffset=buf.getcurrentoffset() 
 510          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 511   
 512   
 513 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 514          'Reads this packet from the supplied buffer' 
 515          self._bufferstartoffset=buf.getcurrentoffset() 
 516          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 517          self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PBOKW=0,'}) 
 518          self.__field_command.readfrombuffer(buf) 
 519          self.__field_entry=pbentry() 
 520          self.__field_entry.readfrombuffer(buf) 
 521          self._bufferendoffset=buf.getcurrentoffset() 
 522   
 523   
 524 -    def __getfield_command(self): 
 525          try: self.__field_command 
 526          except: 
 527              self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PBOKW=0,'}) 
 528          return self.__field_command.getvalue() 
 529   
 530 -    def __setfield_command(self, value): 
 531          if isinstance(value,CSVSTRING): 
 532              self.__field_command=value 
 533          else: 
 534              self.__field_command=CSVSTRING(value,**{'quotechar': None, 'terminator': None, 'default': '#PBOKW=0,'}) 
 535   
 536 -    def __delfield_command(self): del self.__field_command 
 537   
 538      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
 539   
 540 -    def __getfield_entry(self): 
 541          return self.__field_entry.getvalue() 
 542   
 543 -    def __setfield_entry(self, value): 
 544          if isinstance(value,pbentry): 
 545              self.__field_entry=value 
 546          else: 
 547              self.__field_entry=pbentry(value,) 
 548   
 549 -    def __delfield_entry(self): del self.__field_entry 
 550   
 551      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
 552   
 553 -    def iscontainer(self): 
 554          return True 
 555   
 556 -    def containerelements(self): 
 557          yield ('command', self.__field_command, None) 
 558          yield ('entry', self.__field_entry, None) 
 559   
 560   
 561   
 562   
 563 -class groupnameresponse(BaseProtogenClass): 
 564      __fields=['command', 'entry'] 
 565   
 566 -    def __init__(self, *args, **kwargs): 
 567          dict={} 
 568          # What was supplied to this function 
 569          dict.update(kwargs) 
 570          # Parent constructor 
 571          super(groupnameresponse,self).__init__(**dict) 
 572          if self.__class__ is groupnameresponse: 
 573              self._update(args,dict) 
 574   
 575   
 576 -    def getfields(self): 
 577          return self.__fields 
 578   
 579   
 580 -    def _update(self, args, kwargs): 
 581          super(groupnameresponse,self)._update(args,kwargs) 
 582          keys=kwargs.keys() 
 583          for key in keys: 
 584              if key in self.__fields: 
 585                  setattr(self, key, kwargs[key]) 
 586                  del kwargs[key] 
 587          # Were any unrecognized kwargs passed in? 
 588          if __debug__: 
 589              self._complainaboutunusedargs(groupnameresponse,kwargs) 
 590          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 591          # Make all P fields that haven't already been constructed 
 592   
 593   
 594 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 595          'Writes this packet to the supplied buffer' 
 596          self._bufferstartoffset=buf.getcurrentoffset() 
 597          self.__field_command.writetobuffer(buf) 
 598          self.__field_entry.writetobuffer(buf) 
 599          self._bufferendoffset=buf.getcurrentoffset() 
 600          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 601   
 602   
 603 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 604          'Reads this packet from the supplied buffer' 
 605          self._bufferstartoffset=buf.getcurrentoffset() 
 606          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 607          self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': ord(' '), 'constant': '#PBGRR:'}) 
 608          self.__field_command.readfrombuffer(buf) 
 609          self.__field_entry=groupnameentry() 
 610          self.__field_entry.readfrombuffer(buf) 
 611          self._bufferendoffset=buf.getcurrentoffset() 
 612   
 613   
 614 -    def __getfield_command(self): 
 615          return self.__field_command.getvalue() 
 616   
 617 -    def __setfield_command(self, value): 
 618          if isinstance(value,CSVSTRING): 
 619              self.__field_command=value 
 620          else: 
 621              self.__field_command=CSVSTRING(value,**{'quotechar': None, 'terminator': ord(' '), 'constant': '#PBGRR:'}) 
 622   
 623 -    def __delfield_command(self): del self.__field_command 
 624   
 625      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
 626   
 627 -    def __getfield_entry(self): 
 628          return self.__field_entry.getvalue() 
 629   
 630 -    def __setfield_entry(self, value): 
 631          if isinstance(value,groupnameentry): 
 632              self.__field_entry=value 
 633          else: 
 634              self.__field_entry=groupnameentry(value,) 
 635   
 636 -    def __delfield_entry(self): del self.__field_entry 
 637   
 638      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
 639   
 640 -    def iscontainer(self): 
 641          return True 
 642   
 643 -    def containerelements(self): 
 644          yield ('command', self.__field_command, None) 
 645          yield ('entry', self.__field_entry, None) 
 646   
 647   
 648   
 649   
 650 -class groupnameentry(BaseProtogenClass): 
 651      __fields=['gid', 'groupname', 'ringtone', 'dunno2', 'timestamp'] 
 652   
 653 -    def __init__(self, *args, **kwargs): 
 654          dict={} 
 655          # What was supplied to this function 
 656          dict.update(kwargs) 
 657          # Parent constructor 
 658          super(groupnameentry,self).__init__(**dict) 
 659          if self.__class__ is groupnameentry: 
 660              self._update(args,dict) 
 661   
 662   
 663 -    def getfields(self): 
 664          return self.__fields 
 665   
 666   
 667 -    def _update(self, args, kwargs): 
 668          super(groupnameentry,self)._update(args,kwargs) 
 669          keys=kwargs.keys() 
 670          for key in keys: 
 671              if key in self.__fields: 
 672                  setattr(self, key, kwargs[key]) 
 673                  del kwargs[key] 
 674          # Were any unrecognized kwargs passed in? 
 675          if __debug__: 
 676              self._complainaboutunusedargs(groupnameentry,kwargs) 
 677          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 678          # Make all P fields that haven't already been constructed 
 679   
 680   
 681 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 682          'Writes this packet to the supplied buffer' 
 683          self._bufferstartoffset=buf.getcurrentoffset() 
 684          self.__field_gid.writetobuffer(buf) 
 685          self.__field_groupname.writetobuffer(buf) 
 686          self.__field_ringtone.writetobuffer(buf) 
 687          self.__field_dunno2.writetobuffer(buf) 
 688          self.__field_timestamp.writetobuffer(buf) 
 689          self._bufferendoffset=buf.getcurrentoffset() 
 690          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 691   
 692   
 693 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 694          'Reads this packet from the supplied buffer' 
 695          self._bufferstartoffset=buf.getcurrentoffset() 
 696          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 697          self.__field_gid=CSVINT() 
 698          self.__field_gid.readfrombuffer(buf) 
 699          self.__field_groupname=CSVSTRING() 
 700          self.__field_groupname.readfrombuffer(buf) 
 701          self.__field_ringtone=CSVINT() 
 702          self.__field_ringtone.readfrombuffer(buf) 
 703          self.__field_dunno2=CSVSTRING(**{'quotechar': None}) 
 704          self.__field_dunno2.readfrombuffer(buf) 
 705          self.__field_timestamp=CSVTIME(**{'terminator': None}) 
 706          self.__field_timestamp.readfrombuffer(buf) 
 707          self._bufferendoffset=buf.getcurrentoffset() 
 708   
 709   
 710 -    def __getfield_gid(self): 
 711          return self.__field_gid.getvalue() 
 712   
 713 -    def __setfield_gid(self, value): 
 714          if isinstance(value,CSVINT): 
 715              self.__field_gid=value 
 716          else: 
 717              self.__field_gid=CSVINT(value,) 
 718   
 719 -    def __delfield_gid(self): del self.__field_gid 
 720   
 721      gid=property(__getfield_gid, __setfield_gid, __delfield_gid, None) 
 722   
 723 -    def __getfield_groupname(self): 
 724          return self.__field_groupname.getvalue() 
 725   
 726 -    def __setfield_groupname(self, value): 
 727          if isinstance(value,CSVSTRING): 
 728              self.__field_groupname=value 
 729          else: 
 730              self.__field_groupname=CSVSTRING(value,) 
 731   
 732 -    def __delfield_groupname(self): del self.__field_groupname 
 733   
 734      groupname=property(__getfield_groupname, __setfield_groupname, __delfield_groupname, None) 
 735   
 736 -    def __getfield_ringtone(self): 
 737          return self.__field_ringtone.getvalue() 
 738   
 739 -    def __setfield_ringtone(self, value): 
 740          if isinstance(value,CSVINT): 
 741              self.__field_ringtone=value 
 742          else: 
 743              self.__field_ringtone=CSVINT(value,) 
 744   
 745 -    def __delfield_ringtone(self): del self.__field_ringtone 
 746   
 747      ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, "Ringtone assignment?") 
 748   
 749 -    def __getfield_dunno2(self): 
 750          return self.__field_dunno2.getvalue() 
 751   
 752 -    def __setfield_dunno2(self, value): 
 753          if isinstance(value,CSVSTRING): 
 754              self.__field_dunno2=value 
 755          else: 
 756              self.__field_dunno2=CSVSTRING(value,**{'quotechar': None}) 
 757   
 758 -    def __delfield_dunno2(self): del self.__field_dunno2 
 759   
 760      dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, "A single character C or S") 
 761   
 762 -    def __getfield_timestamp(self): 
 763          return self.__field_timestamp.getvalue() 
 764   
 765 -    def __setfield_timestamp(self, value): 
 766          if isinstance(value,CSVTIME): 
 767              self.__field_timestamp=value 
 768          else: 
 769              self.__field_timestamp=CSVTIME(value,**{'terminator': None}) 
 770   
 771 -    def __delfield_timestamp(self): del self.__field_timestamp 
 772   
 773      timestamp=property(__getfield_timestamp, __setfield_timestamp, __delfield_timestamp, None) 
 774   
 775 -    def iscontainer(self): 
 776          return True 
 777   
 778 -    def containerelements(self): 
 779          yield ('gid', self.__field_gid, None) 
 780          yield ('groupname', self.__field_groupname, None) 
 781          yield ('ringtone', self.__field_ringtone, "Ringtone assignment?") 
 782          yield ('dunno2', self.__field_dunno2, "A single character C or S") 
 783          yield ('timestamp', self.__field_timestamp, None) 
 784   
 785   
 786   
 787   
 788 -class unparsedresponse(BaseProtogenClass): 
 789      __fields=['pad'] 
 790   
 791 -    def __init__(self, *args, **kwargs): 
 792          dict={} 
 793          # What was supplied to this function 
 794          dict.update(kwargs) 
 795          # Parent constructor 
 796          super(unparsedresponse,self).__init__(**dict) 
 797          if self.__class__ is unparsedresponse: 
 798              self._update(args,dict) 
 799   
 800   
 801 -    def getfields(self): 
 802          return self.__fields 
 803   
 804   
 805 -    def _update(self, args, kwargs): 
 806          super(unparsedresponse,self)._update(args,kwargs) 
 807          keys=kwargs.keys() 
 808          for key in keys: 
 809              if key in self.__fields: 
 810                  setattr(self, key, kwargs[key]) 
 811                  del kwargs[key] 
 812          # Were any unrecognized kwargs passed in? 
 813          if __debug__: 
 814              self._complainaboutunusedargs(unparsedresponse,kwargs) 
 815          if len(args): 
 816              dict2={} 
 817              dict2.update(kwargs) 
 818              kwargs=dict2 
 819              self.__field_pad=UNKNOWN(*args,**dict2) 
 820          # Make all P fields that haven't already been constructed 
 821   
 822   
 823 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 824          'Writes this packet to the supplied buffer' 
 825          self._bufferstartoffset=buf.getcurrentoffset() 
 826          self.__field_pad.writetobuffer(buf) 
 827          self._bufferendoffset=buf.getcurrentoffset() 
 828          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 829   
 830   
 831 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 832          'Reads this packet from the supplied buffer' 
 833          self._bufferstartoffset=buf.getcurrentoffset() 
 834          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 835          self.__field_pad=UNKNOWN() 
 836          self.__field_pad.readfrombuffer(buf) 
 837          self._bufferendoffset=buf.getcurrentoffset() 
 838   
 839   
 840 -    def __getfield_pad(self): 
 841          return self.__field_pad.getvalue() 
 842   
 843 -    def __setfield_pad(self, value): 
 844          if isinstance(value,UNKNOWN): 
 845              self.__field_pad=value 
 846          else: 
 847              self.__field_pad=UNKNOWN(value,) 
 848   
 849 -    def __delfield_pad(self): del self.__field_pad 
 850   
 851      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
 852   
 853 -    def iscontainer(self): 
 854          return True 
 855   
 856 -    def containerelements(self): 
 857          yield ('pad', self.__field_pad, None) 
 858   
 859   
 860   
 861   
 862 -class filepbentry(BaseProtogenClass): 
 863      __fields=['dunno1', 'dunno2', 'dunno3', 'dunno4', 'dunno5', 'dunno6', 'dunno7', 'dunno8', 'dunno9', 'slot', 'dunno10', 'dunno11', 'dunno12', 'dunno13', 'dunno14', 'dunno15', 'dunno16', 'dunno17', 'dunno18', 'dunno19', 'dunno20', 'dunno21', 'name_len', 'name', 'birthday', 'group_num'] 
 864   
 865 -    def __init__(self, *args, **kwargs): 
 866          dict={} 
 867          # What was supplied to this function 
 868          dict.update(kwargs) 
 869          # Parent constructor 
 870          super(filepbentry,self).__init__(**dict) 
 871          if self.__class__ is filepbentry: 
 872              self._update(args,dict) 
 873   
 874   
 875 -    def getfields(self): 
 876          return self.__fields 
 877   
 878   
 879 -    def _update(self, args, kwargs): 
 880          super(filepbentry,self)._update(args,kwargs) 
 881          keys=kwargs.keys() 
 882          for key in keys: 
 883              if key in self.__fields: 
 884                  setattr(self, key, kwargs[key]) 
 885                  del kwargs[key] 
 886          # Were any unrecognized kwargs passed in? 
 887          if __debug__: 
 888              self._complainaboutunusedargs(filepbentry,kwargs) 
 889          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 890          # Make all P fields that haven't already been constructed 
 891   
 892   
 893 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 894          'Writes this packet to the supplied buffer' 
 895          self._bufferstartoffset=buf.getcurrentoffset() 
 896          self.__field_dunno1.writetobuffer(buf) 
 897          self.__field_dunno2.writetobuffer(buf) 
 898          self.__field_dunno3.writetobuffer(buf) 
 899          self.__field_dunno4.writetobuffer(buf) 
 900          self.__field_dunno5.writetobuffer(buf) 
 901          self.__field_dunno6.writetobuffer(buf) 
 902          self.__field_dunno7.writetobuffer(buf) 
 903          self.__field_dunno8.writetobuffer(buf) 
 904          self.__field_dunno9.writetobuffer(buf) 
 905          self.__field_slot.writetobuffer(buf) 
 906          self.__field_dunno10.writetobuffer(buf) 
 907          self.__field_dunno11.writetobuffer(buf) 
 908          self.__field_dunno12.writetobuffer(buf) 
 909          self.__field_dunno13.writetobuffer(buf) 
 910          self.__field_dunno14.writetobuffer(buf) 
 911          self.__field_dunno15.writetobuffer(buf) 
 912          self.__field_dunno16.writetobuffer(buf) 
 913          self.__field_dunno17.writetobuffer(buf) 
 914          self.__field_dunno18.writetobuffer(buf) 
 915          self.__field_dunno19.writetobuffer(buf) 
 916          self.__field_dunno20.writetobuffer(buf) 
 917          self.__field_dunno21.writetobuffer(buf) 
 918          self.__field_name_len.writetobuffer(buf) 
 919          self.__field_name.writetobuffer(buf) 
 920          self.__field_birthday.writetobuffer(buf) 
 921          self.__field_group_num.writetobuffer(buf) 
 922          self._bufferendoffset=buf.getcurrentoffset() 
 923          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 924   
 925   
 926 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 927          'Reads this packet from the supplied buffer' 
 928          self._bufferstartoffset=buf.getcurrentoffset() 
 929          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 930          self.__field_dunno1=UINT(**{'sizeinbytes': 1}) 
 931          self.__field_dunno1.readfrombuffer(buf) 
 932          self.__field_dunno2=UINT(**{'sizeinbytes': 1}) 
 933          self.__field_dunno2.readfrombuffer(buf) 
 934          self.__field_dunno3=UINT(**{'sizeinbytes': 1}) 
 935          self.__field_dunno3.readfrombuffer(buf) 
 936          self.__field_dunno4=UINT(**{'sizeinbytes': 1}) 
 937          self.__field_dunno4.readfrombuffer(buf) 
 938          self.__field_dunno5=UINT(**{'sizeinbytes': 1}) 
 939          self.__field_dunno5.readfrombuffer(buf) 
 940          self.__field_dunno6=UINT(**{'sizeinbytes': 1}) 
 941          self.__field_dunno6.readfrombuffer(buf) 
 942          self.__field_dunno7=UINT(**{'sizeinbytes': 1}) 
 943          self.__field_dunno7.readfrombuffer(buf) 
 944          self.__field_dunno8=UINT(**{'sizeinbytes': 1}) 
 945          self.__field_dunno8.readfrombuffer(buf) 
 946          self.__field_dunno9=UINT(**{'sizeinbytes': 1}) 
 947          self.__field_dunno9.readfrombuffer(buf) 
 948          self.__field_slot=UINT(**{'sizeinbytes': 2}) 
 949          self.__field_slot.readfrombuffer(buf) 
 950          self.__field_dunno10=UINT(**{'sizeinbytes': 1}) 
 951          self.__field_dunno10.readfrombuffer(buf) 
 952          self.__field_dunno11=UINT(**{'sizeinbytes': 1}) 
 953          self.__field_dunno11.readfrombuffer(buf) 
 954          self.__field_dunno12=UINT(**{'sizeinbytes': 1}) 
 955          self.__field_dunno12.readfrombuffer(buf) 
 956          self.__field_dunno13=UINT(**{'sizeinbytes': 1}) 
 957          self.__field_dunno13.readfrombuffer(buf) 
 958          self.__field_dunno14=UINT(**{'sizeinbytes': 1}) 
 959          self.__field_dunno14.readfrombuffer(buf) 
 960          self.__field_dunno15=UINT(**{'sizeinbytes': 1}) 
 961          self.__field_dunno15.readfrombuffer(buf) 
 962          self.__field_dunno16=UINT(**{'sizeinbytes': 1}) 
 963          self.__field_dunno16.readfrombuffer(buf) 
 964          self.__field_dunno17=UINT(**{'sizeinbytes': 1}) 
 965          self.__field_dunno17.readfrombuffer(buf) 
 966          self.__field_dunno18=UINT(**{'sizeinbytes': 1}) 
 967          self.__field_dunno18.readfrombuffer(buf) 
 968          self.__field_dunno19=UINT(**{'sizeinbytes': 1}) 
 969          self.__field_dunno19.readfrombuffer(buf) 
 970          self.__field_dunno20=UINT(**{'sizeinbytes': 1}) 
 971          self.__field_dunno20.readfrombuffer(buf) 
 972          self.__field_dunno21=UINT(**{'sizeinbytes': 1}) 
 973          self.__field_dunno21.readfrombuffer(buf) 
 974          self.__field_name_len=UINT(**{'sizeinbytes': 1}) 
 975          self.__field_name_len.readfrombuffer(buf) 
 976          self.__field_name=USTRING(**{'sizeinbytes': 21, 'raiseonunterminatedread': False }) 
 977          self.__field_name.readfrombuffer(buf) 
 978          self.__field_birthday=USTRING(**{'sizeinbytes': 11}) 
 979          self.__field_birthday.readfrombuffer(buf) 
 980          self.__field_group_num=UINT(**{'sizeinbytes': 1}) 
 981          self.__field_group_num.readfrombuffer(buf) 
 982          self._bufferendoffset=buf.getcurrentoffset() 
 983   
 984   
 985 -    def __getfield_dunno1(self): 
 986          return self.__field_dunno1.getvalue() 
 987   
 988 -    def __setfield_dunno1(self, value): 
 989          if isinstance(value,UINT): 
 990              self.__field_dunno1=value 
 991          else: 
 992              self.__field_dunno1=UINT(value,**{'sizeinbytes': 1}) 
 993   
 994 -    def __delfield_dunno1(self): del self.__field_dunno1 
 995   
 996      dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None) 
 997   
 998 -    def __getfield_dunno2(self): 
 999          return self.__field_dunno2.getvalue() 
1000   
1001 -    def __setfield_dunno2(self, value): 
1002          if isinstance(value,UINT): 
1003              self.__field_dunno2=value 
1004          else: 
1005              self.__field_dunno2=UINT(value,**{'sizeinbytes': 1}) 
1006   
1007 -    def __delfield_dunno2(self): del self.__field_dunno2 
1008   
1009      dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None) 
1010   
1011 -    def __getfield_dunno3(self): 
1012          return self.__field_dunno3.getvalue() 
1013   
1014 -    def __setfield_dunno3(self, value): 
1015          if isinstance(value,UINT): 
1016              self.__field_dunno3=value 
1017          else: 
1018              self.__field_dunno3=UINT(value,**{'sizeinbytes': 1}) 
1019   
1020 -    def __delfield_dunno3(self): del self.__field_dunno3 
1021   
1022      dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None) 
1023   
1024 -    def __getfield_dunno4(self): 
1025          return self.__field_dunno4.getvalue() 
1026   
1027 -    def __setfield_dunno4(self, value): 
1028          if isinstance(value,UINT): 
1029              self.__field_dunno4=value 
1030          else: 
1031              self.__field_dunno4=UINT(value,**{'sizeinbytes': 1}) 
1032   
1033 -    def __delfield_dunno4(self): del self.__field_dunno4 
1034   
1035      dunno4=property(__getfield_dunno4, __setfield_dunno4, __delfield_dunno4, None) 
1036   
1037 -    def __getfield_dunno5(self): 
1038          return self.__field_dunno5.getvalue() 
1039   
1040 -    def __setfield_dunno5(self, value): 
1041          if isinstance(value,UINT): 
1042              self.__field_dunno5=value 
1043          else: 
1044              self.__field_dunno5=UINT(value,**{'sizeinbytes': 1}) 
1045   
1046 -    def __delfield_dunno5(self): del self.__field_dunno5 
1047   
1048      dunno5=property(__getfield_dunno5, __setfield_dunno5, __delfield_dunno5, None) 
1049   
1050 -    def __getfield_dunno6(self): 
1051          return self.__field_dunno6.getvalue() 
1052   
1053 -    def __setfield_dunno6(self, value): 
1054          if isinstance(value,UINT): 
1055              self.__field_dunno6=value 
1056          else: 
1057              self.__field_dunno6=UINT(value,**{'sizeinbytes': 1}) 
1058   
1059 -    def __delfield_dunno6(self): del self.__field_dunno6 
1060   
1061      dunno6=property(__getfield_dunno6, __setfield_dunno6, __delfield_dunno6, None) 
1062   
1063 -    def __getfield_dunno7(self): 
1064          return self.__field_dunno7.getvalue() 
1065   
1066 -    def __setfield_dunno7(self, value): 
1067          if isinstance(value,UINT): 
1068              self.__field_dunno7=value 
1069          else: 
1070              self.__field_dunno7=UINT(value,**{'sizeinbytes': 1}) 
1071   
1072 -    def __delfield_dunno7(self): del self.__field_dunno7 
1073   
1074      dunno7=property(__getfield_dunno7, __setfield_dunno7, __delfield_dunno7, None) 
1075   
1076 -    def __getfield_dunno8(self): 
1077          return self.__field_dunno8.getvalue() 
1078   
1079 -    def __setfield_dunno8(self, value): 
1080          if isinstance(value,UINT): 
1081              self.__field_dunno8=value 
1082          else: 
1083              self.__field_dunno8=UINT(value,**{'sizeinbytes': 1}) 
1084   
1085 -    def __delfield_dunno8(self): del self.__field_dunno8 
1086   
1087      dunno8=property(__getfield_dunno8, __setfield_dunno8, __delfield_dunno8, None) 
1088   
1089 -    def __getfield_dunno9(self): 
1090          return self.__field_dunno9.getvalue() 
1091   
1092 -    def __setfield_dunno9(self, value): 
1093          if isinstance(value,UINT): 
1094              self.__field_dunno9=value 
1095          else: 
1096              self.__field_dunno9=UINT(value,**{'sizeinbytes': 1}) 
1097   
1098 -    def __delfield_dunno9(self): del self.__field_dunno9 
1099   
1100      dunno9=property(__getfield_dunno9, __setfield_dunno9, __delfield_dunno9, None) 
1101   
1102 -    def __getfield_slot(self): 
1103          return self.__field_slot.getvalue() 
1104   
1105 -    def __setfield_slot(self, value): 
1106          if isinstance(value,UINT): 
1107              self.__field_slot=value 
1108          else: 
1109              self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 
1110   
1111 -    def __delfield_slot(self): del self.__field_slot 
1112   
1113      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
1114   
1115 -    def __getfield_dunno10(self): 
1116          return self.__field_dunno10.getvalue() 
1117   
1118 -    def __setfield_dunno10(self, value): 
1119          if isinstance(value,UINT): 
1120              self.__field_dunno10=value 
1121          else: 
1122              self.__field_dunno10=UINT(value,**{'sizeinbytes': 1}) 
1123   
1124 -    def __delfield_dunno10(self): del self.__field_dunno10 
1125   
1126      dunno10=property(__getfield_dunno10, __setfield_dunno10, __delfield_dunno10, None) 
1127   
1128 -    def __getfield_dunno11(self): 
1129          return self.__field_dunno11.getvalue() 
1130   
1131 -    def __setfield_dunno11(self, value): 
1132          if isinstance(value,UINT): 
1133              self.__field_dunno11=value 
1134          else: 
1135              self.__field_dunno11=UINT(value,**{'sizeinbytes': 1}) 
1136   
1137 -    def __delfield_dunno11(self): del self.__field_dunno11 
1138   
1139      dunno11=property(__getfield_dunno11, __setfield_dunno11, __delfield_dunno11, None) 
1140   
1141 -    def __getfield_dunno12(self): 
1142          return self.__field_dunno12.getvalue() 
1143   
1144 -    def __setfield_dunno12(self, value): 
1145          if isinstance(value,UINT): 
1146              self.__field_dunno12=value 
1147          else: 
1148              self.__field_dunno12=UINT(value,**{'sizeinbytes': 1}) 
1149   
1150 -    def __delfield_dunno12(self): del self.__field_dunno12 
1151   
1152      dunno12=property(__getfield_dunno12, __setfield_dunno12, __delfield_dunno12, None) 
1153   
1154 -    def __getfield_dunno13(self): 
1155          return self.__field_dunno13.getvalue() 
1156   
1157 -    def __setfield_dunno13(self, value): 
1158          if isinstance(value,UINT): 
1159              self.__field_dunno13=value 
1160          else: 
1161              self.__field_dunno13=UINT(value,**{'sizeinbytes': 1}) 
1162   
1163 -    def __delfield_dunno13(self): del self.__field_dunno13 
1164   
1165      dunno13=property(__getfield_dunno13, __setfield_dunno13, __delfield_dunno13, None) 
1166   
1167 -    def __getfield_dunno14(self): 
1168          return self.__field_dunno14.getvalue() 
1169   
1170 -    def __setfield_dunno14(self, value): 
1171          if isinstance(value,UINT): 
1172              self.__field_dunno14=value 
1173          else: 
1174              self.__field_dunno14=UINT(value,**{'sizeinbytes': 1}) 
1175   
1176 -    def __delfield_dunno14(self): del self.__field_dunno14 
1177   
1178      dunno14=property(__getfield_dunno14, __setfield_dunno14, __delfield_dunno14, None) 
1179   
1180 -    def __getfield_dunno15(self): 
1181          return self.__field_dunno15.getvalue() 
1182   
1183 -    def __setfield_dunno15(self, value): 
1184          if isinstance(value,UINT): 
1185              self.__field_dunno15=value 
1186          else: 
1187              self.__field_dunno15=UINT(value,**{'sizeinbytes': 1}) 
1188   
1189 -    def __delfield_dunno15(self): del self.__field_dunno15 
1190   
1191      dunno15=property(__getfield_dunno15, __setfield_dunno15, __delfield_dunno15, None) 
1192   
1193 -    def __getfield_dunno16(self): 
1194          return self.__field_dunno16.getvalue() 
1195   
1196 -    def __setfield_dunno16(self, value): 
1197          if isinstance(value,UINT): 
1198              self.__field_dunno16=value 
1199          else: 
1200              self.__field_dunno16=UINT(value,**{'sizeinbytes': 1}) 
1201   
1202 -    def __delfield_dunno16(self): del self.__field_dunno16 
1203   
1204      dunno16=property(__getfield_dunno16, __setfield_dunno16, __delfield_dunno16, None) 
1205   
1206 -    def __getfield_dunno17(self): 
1207          return self.__field_dunno17.getvalue() 
1208   
1209 -    def __setfield_dunno17(self, value): 
1210          if isinstance(value,UINT): 
1211              self.__field_dunno17=value 
1212          else: 
1213              self.__field_dunno17=UINT(value,**{'sizeinbytes': 1}) 
1214   
1215 -    def __delfield_dunno17(self): del self.__field_dunno17 
1216   
1217      dunno17=property(__getfield_dunno17, __setfield_dunno17, __delfield_dunno17, None) 
1218   
1219 -    def __getfield_dunno18(self): 
1220          return self.__field_dunno18.getvalue() 
1221   
1222 -    def __setfield_dunno18(self, value): 
1223          if isinstance(value,UINT): 
1224              self.__field_dunno18=value 
1225          else: 
1226              self.__field_dunno18=UINT(value,**{'sizeinbytes': 1}) 
1227   
1228 -    def __delfield_dunno18(self): del self.__field_dunno18 
1229   
1230      dunno18=property(__getfield_dunno18, __setfield_dunno18, __delfield_dunno18, None) 
1231   
1232 -    def __getfield_dunno19(self): 
1233          return self.__field_dunno19.getvalue() 
1234   
1235 -    def __setfield_dunno19(self, value): 
1236          if isinstance(value,UINT): 
1237              self.__field_dunno19=value 
1238          else: 
1239              self.__field_dunno19=UINT(value,**{'sizeinbytes': 1}) 
1240   
1241 -    def __delfield_dunno19(self): del self.__field_dunno19 
1242   
1243      dunno19=property(__getfield_dunno19, __setfield_dunno19, __delfield_dunno19, None) 
1244   
1245 -    def __getfield_dunno20(self): 
1246          return self.__field_dunno20.getvalue() 
1247   
1248 -    def __setfield_dunno20(self, value): 
1249          if isinstance(value,UINT): 
1250              self.__field_dunno20=value 
1251          else: 
1252              self.__field_dunno20=UINT(value,**{'sizeinbytes': 1}) 
1253   
1254 -    def __delfield_dunno20(self): del self.__field_dunno20 
1255   
1256      dunno20=property(__getfield_dunno20, __setfield_dunno20, __delfield_dunno20, None) 
1257   
1258 -    def __getfield_dunno21(self): 
1259          return self.__field_dunno21.getvalue() 
1260   
1261 -    def __setfield_dunno21(self, value): 
1262          if isinstance(value,UINT): 
1263              self.__field_dunno21=value 
1264          else: 
1265              self.__field_dunno21=UINT(value,**{'sizeinbytes': 1}) 
1266   
1267 -    def __delfield_dunno21(self): del self.__field_dunno21 
1268   
1269      dunno21=property(__getfield_dunno21, __setfield_dunno21, __delfield_dunno21, None) 
1270   
1271 -    def __getfield_name_len(self): 
1272          return self.__field_name_len.getvalue() 
1273   
1274 -    def __setfield_name_len(self, value): 
1275          if isinstance(value,UINT): 
1276              self.__field_name_len=value 
1277          else: 
1278              self.__field_name_len=UINT(value,**{'sizeinbytes': 1}) 
1279   
1280 -    def __delfield_name_len(self): del self.__field_name_len 
1281   
1282      name_len=property(__getfield_name_len, __setfield_name_len, __delfield_name_len, None) 
1283   
1284 -    def __getfield_name(self): 
1285          return self.__field_name.getvalue() 
1286   
1287 -    def __setfield_name(self, value): 
1288          if isinstance(value,USTRING): 
1289              self.__field_name=value 
1290          else: 
1291              self.__field_name=USTRING(value,**{'sizeinbytes': 21, 'raiseonunterminatedread': False }) 
1292   
1293 -    def __delfield_name(self): del self.__field_name 
1294   
1295      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
1296   
1297 -    def __getfield_birthday(self): 
1298          return self.__field_birthday.getvalue() 
1299   
1300 -    def __setfield_birthday(self, value): 
1301          if isinstance(value,USTRING): 
1302              self.__field_birthday=value 
1303          else: 
1304              self.__field_birthday=USTRING(value,**{'sizeinbytes': 11}) 
1305   
1306 -    def __delfield_birthday(self): del self.__field_birthday 
1307   
1308      birthday=property(__getfield_birthday, __setfield_birthday, __delfield_birthday, None) 
1309   
1310 -    def __getfield_group_num(self): 
1311          return self.__field_group_num.getvalue() 
1312   
1313 -    def __setfield_group_num(self, value): 
1314          if isinstance(value,UINT): 
1315              self.__field_group_num=value 
1316          else: 
1317              self.__field_group_num=UINT(value,**{'sizeinbytes': 1}) 
1318   
1319 -    def __delfield_group_num(self): del self.__field_group_num 
1320   
1321      group_num=property(__getfield_group_num, __setfield_group_num, __delfield_group_num, None) 
1322   
1323 -    def iscontainer(self): 
1324          return True 
1325   
1326 -    def containerelements(self): 
1327          yield ('dunno1', self.__field_dunno1, None) 
1328          yield ('dunno2', self.__field_dunno2, None) 
1329          yield ('dunno3', self.__field_dunno3, None) 
1330          yield ('dunno4', self.__field_dunno4, None) 
1331          yield ('dunno5', self.__field_dunno5, None) 
1332          yield ('dunno6', self.__field_dunno6, None) 
1333          yield ('dunno7', self.__field_dunno7, None) 
1334          yield ('dunno8', self.__field_dunno8, None) 
1335          yield ('dunno9', self.__field_dunno9, None) 
1336          yield ('slot', self.__field_slot, None) 
1337          yield ('dunno10', self.__field_dunno10, None) 
1338          yield ('dunno11', self.__field_dunno11, None) 
1339          yield ('dunno12', self.__field_dunno12, None) 
1340          yield ('dunno13', self.__field_dunno13, None) 
1341          yield ('dunno14', self.__field_dunno14, None) 
1342          yield ('dunno15', self.__field_dunno15, None) 
1343          yield ('dunno16', self.__field_dunno16, None) 
1344          yield ('dunno17', self.__field_dunno17, None) 
1345          yield ('dunno18', self.__field_dunno18, None) 
1346          yield ('dunno19', self.__field_dunno19, None) 
1347          yield ('dunno20', self.__field_dunno20, None) 
1348          yield ('dunno21', self.__field_dunno21, None) 
1349          yield ('name_len', self.__field_name_len, None) 
1350          yield ('name', self.__field_name, None) 
1351          yield ('birthday', self.__field_birthday, None) 
1352          yield ('group_num', self.__field_group_num, None) 
1353   
1354   
1355   
1356   
1357 -class pbbook(BaseProtogenClass): 
1358      __fields=['dummy', 'entry'] 
1359   
1360 -    def __init__(self, *args, **kwargs): 
1361          dict={} 
1362          # What was supplied to this function 
1363          dict.update(kwargs) 
1364          # Parent constructor 
1365          super(pbbook,self).__init__(**dict) 
1366          if self.__class__ is pbbook: 
1367              self._update(args,dict) 
1368   
1369   
1370 -    def getfields(self): 
1371          return self.__fields 
1372   
1373   
1374 -    def _update(self, args, kwargs): 
1375          super(pbbook,self)._update(args,kwargs) 
1376          keys=kwargs.keys() 
1377          for key in keys: 
1378              if key in self.__fields: 
1379                  setattr(self, key, kwargs[key]) 
1380                  del kwargs[key] 
1381          # Were any unrecognized kwargs passed in? 
1382          if __debug__: 
1383              self._complainaboutunusedargs(pbbook,kwargs) 
1384          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1385          # Make all P fields that haven't already been constructed 
1386   
1387   
1388 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1389          'Writes this packet to the supplied buffer' 
1390          self._bufferstartoffset=buf.getcurrentoffset() 
1391          self.__field_dummy.writetobuffer(buf) 
1392          try: self.__field_entry 
1393          except: 
1394              self.__field_entry=LIST(**{ 'length': 300, 'elementclass': filepbentry }) 
1395          self.__field_entry.writetobuffer(buf) 
1396          self._bufferendoffset=buf.getcurrentoffset() 
1397          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1398   
1399   
1400 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1401          'Reads this packet from the supplied buffer' 
1402          self._bufferstartoffset=buf.getcurrentoffset() 
1403          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1404          self.__field_dummy=pbentry() 
1405          self.__field_dummy.readfrombuffer(buf) 
1406          self.__field_entry=LIST(**{ 'length': 300, 'elementclass': filepbentry }) 
1407          self.__field_entry.readfrombuffer(buf) 
1408          self._bufferendoffset=buf.getcurrentoffset() 
1409   
1410   
1411 -    def __getfield_dummy(self): 
1412          return self.__field_dummy.getvalue() 
1413   
1414 -    def __setfield_dummy(self, value): 
1415          if isinstance(value,pbentry): 
1416              self.__field_dummy=value 
1417          else: 
1418              self.__field_dummy=pbentry(value,) 
1419   
1420 -    def __delfield_dummy(self): del self.__field_dummy 
1421   
1422      dummy=property(__getfield_dummy, __setfield_dummy, __delfield_dummy, None) 
1423   
1424 -    def __getfield_entry(self): 
1425          try: self.__field_entry 
1426          except: 
1427              self.__field_entry=LIST(**{ 'length': 300, 'elementclass': filepbentry }) 
1428          return self.__field_entry.getvalue() 
1429   
1430 -    def __setfield_entry(self, value): 
1431          if isinstance(value,LIST): 
1432              self.__field_entry=value 
1433          else: 
1434              self.__field_entry=LIST(value,**{ 'length': 300, 'elementclass': filepbentry }) 
1435   
1436 -    def __delfield_entry(self): del self.__field_entry 
1437   
1438      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
1439   
1440 -    def iscontainer(self): 
1441          return True 
1442   
1443 -    def containerelements(self): 
1444          yield ('dummy', self.__field_dummy, None) 
1445          yield ('entry', self.__field_entry, None) 
1446   
1447   
1448   
1449   
1450 -class image(BaseProtogenClass): 
1451      __fields=['inuse', 'pic_type', 'pic_id'] 
1452   
1453 -    def __init__(self, *args, **kwargs): 
1454          dict={} 
1455          # What was supplied to this function 
1456          dict.update(kwargs) 
1457          # Parent constructor 
1458          super(image,self).__init__(**dict) 
1459          if self.__class__ is image: 
1460              self._update(args,dict) 
1461   
1462   
1463 -    def getfields(self): 
1464          return self.__fields 
1465   
1466   
1467 -    def _update(self, args, kwargs): 
1468          super(image,self)._update(args,kwargs) 
1469          keys=kwargs.keys() 
1470          for key in keys: 
1471              if key in self.__fields: 
1472                  setattr(self, key, kwargs[key]) 
1473                  del kwargs[key] 
1474          # Were any unrecognized kwargs passed in? 
1475          if __debug__: 
1476              self._complainaboutunusedargs(image,kwargs) 
1477          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1478          # Make all P fields that haven't already been constructed 
1479   
1480   
1481 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1482          'Writes this packet to the supplied buffer' 
1483          self._bufferstartoffset=buf.getcurrentoffset() 
1484          self.__field_inuse.writetobuffer(buf) 
1485          self.__field_pic_type.writetobuffer(buf) 
1486          self.__field_pic_id.writetobuffer(buf) 
1487          self._bufferendoffset=buf.getcurrentoffset() 
1488          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1489   
1490   
1491 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1492          'Reads this packet from the supplied buffer' 
1493          self._bufferstartoffset=buf.getcurrentoffset() 
1494          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1495          self.__field_inuse=UINT(**{'sizeinbytes': 1}) 
1496          self.__field_inuse.readfrombuffer(buf) 
1497          self.__field_pic_type=UINT(**{'sizeinbytes': 1}) 
1498          self.__field_pic_type.readfrombuffer(buf) 
1499          self.__field_pic_id=UINT(**{'sizeinbytes': 1}) 
1500          self.__field_pic_id.readfrombuffer(buf) 
1501          self._bufferendoffset=buf.getcurrentoffset() 
1502   
1503   
1504 -    def __getfield_inuse(self): 
1505          return self.__field_inuse.getvalue() 
1506   
1507 -    def __setfield_inuse(self, value): 
1508          if isinstance(value,UINT): 
1509              self.__field_inuse=value 
1510          else: 
1511              self.__field_inuse=UINT(value,**{'sizeinbytes': 1}) 
1512   
1513 -    def __delfield_inuse(self): del self.__field_inuse 
1514   
1515      inuse=property(__getfield_inuse, __setfield_inuse, __delfield_inuse, None) 
1516   
1517 -    def __getfield_pic_type(self): 
1518          return self.__field_pic_type.getvalue() 
1519   
1520 -    def __setfield_pic_type(self, value): 
1521          if isinstance(value,UINT): 
1522              self.__field_pic_type=value 
1523          else: 
1524              self.__field_pic_type=UINT(value,**{'sizeinbytes': 1}) 
1525   
1526 -    def __delfield_pic_type(self): del self.__field_pic_type 
1527   
1528      pic_type=property(__getfield_pic_type, __setfield_pic_type, __delfield_pic_type, "1: Man, 2: Animals, 3: Other, 4: Downloads, 5: Pic Wallet") 
1529   
1530 -    def __getfield_pic_id(self): 
1531          return self.__field_pic_id.getvalue() 
1532   
1533 -    def __setfield_pic_id(self, value): 
1534          if isinstance(value,UINT): 
1535              self.__field_pic_id=value 
1536          else: 
1537              self.__field_pic_id=UINT(value,**{'sizeinbytes': 1}) 
1538   
1539 -    def __delfield_pic_id(self): del self.__field_pic_id 
1540   
1541      pic_id=property(__getfield_pic_id, __setfield_pic_id, __delfield_pic_id, None) 
1542   
1543 -    def iscontainer(self): 
1544          return True 
1545   
1546 -    def containerelements(self): 
1547          yield ('inuse', self.__field_inuse, None) 
1548          yield ('pic_type', self.__field_pic_type, "1: Man, 2: Animals, 3: Other, 4: Downloads, 5: Pic Wallet") 
1549          yield ('pic_id', self.__field_pic_id, None) 
1550   
1551   
1552   
1553   
1554 -class avatars(BaseProtogenClass): 
1555      __fields=['dummy', 'entry'] 
1556   
1557 -    def __init__(self, *args, **kwargs): 
1558          dict={} 
1559          # What was supplied to this function 
1560          dict.update(kwargs) 
1561          # Parent constructor 
1562          super(avatars,self).__init__(**dict) 
1563          if self.__class__ is avatars: 
1564              self._update(args,dict) 
1565   
1566   
1567 -    def getfields(self): 
1568          return self.__fields 
1569   
1570   
1571 -    def _update(self, args, kwargs): 
1572          super(avatars,self)._update(args,kwargs) 
1573          keys=kwargs.keys() 
1574          for key in keys: 
1575              if key in self.__fields: 
1576                  setattr(self, key, kwargs[key]) 
1577                  del kwargs[key] 
1578          # Were any unrecognized kwargs passed in? 
1579          if __debug__: 
1580              self._complainaboutunusedargs(avatars,kwargs) 
1581          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1582          # Make all P fields that haven't already been constructed 
1583   
1584   
1585 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1586          'Writes this packet to the supplied buffer' 
1587          self._bufferstartoffset=buf.getcurrentoffset() 
1588          self.__field_dummy.writetobuffer(buf) 
1589          try: self.__field_entry 
1590          except: 
1591              self.__field_entry=LIST(**{'length': NUMPHONEBOOKENTRIES, 'elementclass': image}) 
1592          self.__field_entry.writetobuffer(buf) 
1593          self._bufferendoffset=buf.getcurrentoffset() 
1594          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1595   
1596   
1597 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1598          'Reads this packet from the supplied buffer' 
1599          self._bufferstartoffset=buf.getcurrentoffset() 
1600          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1601          self.__field_dummy=image() 
1602          self.__field_dummy.readfrombuffer(buf) 
1603          self.__field_entry=LIST(**{'length': NUMPHONEBOOKENTRIES, 'elementclass': image}) 
1604          self.__field_entry.readfrombuffer(buf) 
1605          self._bufferendoffset=buf.getcurrentoffset() 
1606   
1607   
1608 -    def __getfield_dummy(self): 
1609          return self.__field_dummy.getvalue() 
1610   
1611 -    def __setfield_dummy(self, value): 
1612          if isinstance(value,image): 
1613              self.__field_dummy=value 
1614          else: 
1615              self.__field_dummy=image(value,) 
1616   
1617 -    def __delfield_dummy(self): del self.__field_dummy 
1618   
1619      dummy=property(__getfield_dummy, __setfield_dummy, __delfield_dummy, None) 
1620   
1621 -    def __getfield_entry(self): 
1622          try: self.__field_entry 
1623          except: 
1624              self.__field_entry=LIST(**{'length': NUMPHONEBOOKENTRIES, 'elementclass': image}) 
1625          return self.__field_entry.getvalue() 
1626   
1627 -    def __setfield_entry(self, value): 
1628          if isinstance(value,LIST): 
1629              self.__field_entry=value 
1630          else: 
1631              self.__field_entry=LIST(value,**{'length': NUMPHONEBOOKENTRIES, 'elementclass': image}) 
1632   
1633 -    def __delfield_entry(self): del self.__field_entry 
1634   
1635      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
1636   
1637 -    def iscontainer(self): 
1638          return True 
1639   
1640 -    def containerelements(self): 
1641          yield ('dummy', self.__field_dummy, None) 
1642          yield ('entry', self.__field_entry, None) 
1643   
1644   
1645   
1646   
1647 -class ringer(BaseProtogenClass): 
1648      __fields=['inuse', 'ring_type', 'ring_id'] 
1649   
1650 -    def __init__(self, *args, **kwargs): 
1651          dict={} 
1652          # What was supplied to this function 
1653          dict.update(kwargs) 
1654          # Parent constructor 
1655          super(ringer,self).__init__(**dict) 
1656          if self.__class__ is ringer: 
1657              self._update(args,dict) 
1658   
1659   
1660 -    def getfields(self): 
1661          return self.__fields 
1662   
1663   
1664 -    def _update(self, args, kwargs): 
1665          super(ringer,self)._update(args,kwargs) 
1666          keys=kwargs.keys() 
1667          for key in keys: 
1668              if key in self.__fields: 
1669                  setattr(self, key, kwargs[key]) 
1670                  del kwargs[key] 
1671          # Were any unrecognized kwargs passed in? 
1672          if __debug__: 
1673              self._complainaboutunusedargs(ringer,kwargs) 
1674          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1675          # Make all P fields that haven't already been constructed 
1676   
1677   
1678 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1679          'Writes this packet to the supplied buffer' 
1680          self._bufferstartoffset=buf.getcurrentoffset() 
1681          self.__field_inuse.writetobuffer(buf) 
1682          self.__field_ring_type.writetobuffer(buf) 
1683          self.__field_ring_id.writetobuffer(buf) 
1684          self._bufferendoffset=buf.getcurrentoffset() 
1685          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1686   
1687   
1688 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1689          'Reads this packet from the supplied buffer' 
1690          self._bufferstartoffset=buf.getcurrentoffset() 
1691          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1692          self.__field_inuse=UINT(**{'sizeinbytes': 1}) 
1693          self.__field_inuse.readfrombuffer(buf) 
1694          self.__field_ring_type=UINT(**{'sizeinbytes': 1}) 
1695          self.__field_ring_type.readfrombuffer(buf) 
1696          self.__field_ring_id=UINT(**{'sizeinbytes': 1}) 
1697          self.__field_ring_id.readfrombuffer(buf) 
1698          self._bufferendoffset=buf.getcurrentoffset() 
1699   
1700   
1701 -    def __getfield_inuse(self): 
1702          return self.__field_inuse.getvalue() 
1703   
1704 -    def __setfield_inuse(self, value): 
1705          if isinstance(value,UINT): 
1706              self.__field_inuse=value 
1707          else: 
1708              self.__field_inuse=UINT(value,**{'sizeinbytes': 1}) 
1709   
1710 -    def __delfield_inuse(self): del self.__field_inuse 
1711   
1712      inuse=property(__getfield_inuse, __setfield_inuse, __delfield_inuse, None) 
1713   
1714 -    def __getfield_ring_type(self): 
1715          return self.__field_ring_type.getvalue() 
1716   
1717 -    def __setfield_ring_type(self, value): 
1718          if isinstance(value,UINT): 
1719              self.__field_ring_type=value 
1720          else: 
1721              self.__field_ring_type=UINT(value,**{'sizeinbytes': 1}) 
1722   
1723 -    def __delfield_ring_type(self): del self.__field_ring_type 
1724   
1725      ring_type=property(__getfield_ring_type, __setfield_ring_type, __delfield_ring_type, "0: Default: 1: Ringtones, 2: Melodies, 3: Downloads, 4: Single Tone") 
1726   
1727 -    def __getfield_ring_id(self): 
1728          return self.__field_ring_id.getvalue() 
1729   
1730 -    def __setfield_ring_id(self, value): 
1731          if isinstance(value,UINT): 
1732              self.__field_ring_id=value 
1733          else: 
1734              self.__field_ring_id=UINT(value,**{'sizeinbytes': 1}) 
1735   
1736 -    def __delfield_ring_id(self): del self.__field_ring_id 
1737   
1738      ring_id=property(__getfield_ring_id, __setfield_ring_id, __delfield_ring_id, "0x45 Tone 1, 0x4a = Tone 6, 0x51=Ringtone 1, 5b=Fur Elise") 
1739   
1740 -    def iscontainer(self): 
1741          return True 
1742   
1743 -    def containerelements(self): 
1744          yield ('inuse', self.__field_inuse, None) 
1745          yield ('ring_type', self.__field_ring_type, "0: Default: 1: Ringtones, 2: Melodies, 3: Downloads, 4: Single Tone") 
1746          yield ('ring_id', self.__field_ring_id, "0x45 Tone 1, 0x4a = Tone 6, 0x51=Ringtone 1, 5b=Fur Elise") 
1747   
1748   
1749   
1750   
1751 -class amsregistry(BaseProtogenClass): 
1752      __fields=['items', 'info', 'info2', 'strings', 'num1', 'num2', 'nfiles', 'num4'] 
1753   
1754 -    def __init__(self, *args, **kwargs): 
1755          dict={} 
1756          # What was supplied to this function 
1757          dict.update(kwargs) 
1758          # Parent constructor 
1759          super(amsregistry,self).__init__(**dict) 
1760          if self.__class__ is amsregistry: 
1761              self._update(args,dict) 
1762   
1763   
1764 -    def getfields(self): 
1765          return self.__fields 
1766   
1767   
1768 -    def _update(self, args, kwargs): 
1769          super(amsregistry,self)._update(args,kwargs) 
1770          keys=kwargs.keys() 
1771          for key in keys: 
1772              if key in self.__fields: 
1773                  setattr(self, key, kwargs[key]) 
1774                  del kwargs[key] 
1775          # Were any unrecognized kwargs passed in? 
1776          if __debug__: 
1777              self._complainaboutunusedargs(amsregistry,kwargs) 
1778          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1779          # Make all P fields that haven't already been constructed 
1780   
1781   
1782 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1783          'Writes this packet to the supplied buffer' 
1784          self._bufferstartoffset=buf.getcurrentoffset() 
1785          self.__field_items.writetobuffer(buf) 
1786          self.__field_info.writetobuffer(buf) 
1787          self.__field_info2.writetobuffer(buf) 
1788          self.__field_strings.writetobuffer(buf) 
1789          self.__field_num1.writetobuffer(buf) 
1790          self.__field_num2.writetobuffer(buf) 
1791          self.__field_nfiles.writetobuffer(buf) 
1792          self.__field_num4.writetobuffer(buf) 
1793          self._bufferendoffset=buf.getcurrentoffset() 
1794          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1795   
1796   
1797 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1798          'Reads this packet from the supplied buffer' 
1799          self._bufferstartoffset=buf.getcurrentoffset() 
1800          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1801          self.__field_items=LIST(**{'elementclass': _gen_p_samsungspha620_134, 'length': 150}) 
1802          self.__field_items.readfrombuffer(buf) 
1803          self.__field_info=LIST(**{'elementclass': _gen_p_samsungspha620_137, 'length': 320}) 
1804          self.__field_info.readfrombuffer(buf) 
1805          self.__field_info2=LIST(**{'elementclass': _gen_p_samsungspha620_155, 'length': 100}) 
1806          self.__field_info2.readfrombuffer(buf) 
1807          self.__field_strings=DATA(**{'sizeinbytes': 23000}) 
1808          self.__field_strings.readfrombuffer(buf) 
1809          self.__field_num1=UINT(**{'sizeinbytes': 2}) 
1810          self.__field_num1.readfrombuffer(buf) 
1811          self.__field_num2=UINT(**{'sizeinbytes': 2}) 
1812          self.__field_num2.readfrombuffer(buf) 
1813          self.__field_nfiles=UINT(**{'sizeinbytes': 2}) 
1814          self.__field_nfiles.readfrombuffer(buf) 
1815          self.__field_num4=UINT(**{'sizeinbytes': 2}) 
1816          self.__field_num4.readfrombuffer(buf) 
1817          self._bufferendoffset=buf.getcurrentoffset() 
1818   
1819   
1820 -    def __getfield_items(self): 
1821          return self.__field_items.getvalue() 
1822   
1823 -    def __setfield_items(self, value): 
1824          if isinstance(value,LIST): 
1825              self.__field_items=value 
1826          else: 
1827              self.__field_items=LIST(value,**{'elementclass': _gen_p_samsungspha620_134, 'length': 150}) 
1828   
1829 -    def __delfield_items(self): del self.__field_items 
1830   
1831      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
1832   
1833 -    def __getfield_info(self): 
1834          return self.__field_info.getvalue() 
1835   
1836 -    def __setfield_info(self, value): 
1837          if isinstance(value,LIST): 
1838              self.__field_info=value 
1839          else: 
1840              self.__field_info=LIST(value,**{'elementclass': _gen_p_samsungspha620_137, 'length': 320}) 
1841   
1842 -    def __delfield_info(self): del self.__field_info 
1843   
1844      info=property(__getfield_info, __setfield_info, __delfield_info, None) 
1845   
1846 -    def __getfield_info2(self): 
1847          return self.__field_info2.getvalue() 
1848   
1849 -    def __setfield_info2(self, value): 
1850          if isinstance(value,LIST): 
1851              self.__field_info2=value 
1852          else: 
1853              self.__field_info2=LIST(value,**{'elementclass': _gen_p_samsungspha620_155, 'length': 100}) 
1854   
1855 -    def __delfield_info2(self): del self.__field_info2 
1856   
1857      info2=property(__getfield_info2, __setfield_info2, __delfield_info2, None) 
1858   
1859 -    def __getfield_strings(self): 
1860          return self.__field_strings.getvalue() 
1861   
1862 -    def __setfield_strings(self, value): 
1863          if isinstance(value,DATA): 
1864              self.__field_strings=value 
1865          else: 
1866              self.__field_strings=DATA(value,**{'sizeinbytes': 23000}) 
1867   
1868 -    def __delfield_strings(self): del self.__field_strings 
1869   
1870      strings=property(__getfield_strings, __setfield_strings, __delfield_strings, None) 
1871   
1872 -    def __getfield_num1(self): 
1873          return self.__field_num1.getvalue() 
1874   
1875 -    def __setfield_num1(self, value): 
1876          if isinstance(value,UINT): 
1877              self.__field_num1=value 
1878          else: 
1879              self.__field_num1=UINT(value,**{'sizeinbytes': 2}) 
1880   
1881 -    def __delfield_num1(self): del self.__field_num1 
1882   
1883      num1=property(__getfield_num1, __setfield_num1, __delfield_num1, None) 
1884   
1885 -    def __getfield_num2(self): 
1886          return self.__field_num2.getvalue() 
1887   
1888 -    def __setfield_num2(self, value): 
1889          if isinstance(value,UINT): 
1890              self.__field_num2=value 
1891          else: 
1892              self.__field_num2=UINT(value,**{'sizeinbytes': 2}) 
1893   
1894 -    def __delfield_num2(self): del self.__field_num2 
1895   
1896      num2=property(__getfield_num2, __setfield_num2, __delfield_num2, None) 
1897   
1898 -    def __getfield_nfiles(self): 
1899          return self.__field_nfiles.getvalue() 
1900   
1901 -    def __setfield_nfiles(self, value): 
1902          if isinstance(value,UINT): 
1903              self.__field_nfiles=value 
1904          else: 
1905              self.__field_nfiles=UINT(value,**{'sizeinbytes': 2}) 
1906   
1907 -    def __delfield_nfiles(self): del self.__field_nfiles 
1908   
1909      nfiles=property(__getfield_nfiles, __setfield_nfiles, __delfield_nfiles, None) 
1910   
1911 -    def __getfield_num4(self): 
1912          return self.__field_num4.getvalue() 
1913   
1914 -    def __setfield_num4(self, value): 
1915          if isinstance(value,UINT): 
1916              self.__field_num4=value 
1917          else: 
1918              self.__field_num4=UINT(value,**{'sizeinbytes': 2}) 
1919   
1920 -    def __delfield_num4(self): del self.__field_num4 
1921   
1922      num4=property(__getfield_num4, __setfield_num4, __delfield_num4, None) 
1923   
1924 -    def iscontainer(self): 
1925          return True 
1926   
1927 -    def containerelements(self): 
1928          yield ('items', self.__field_items, None) 
1929          yield ('info', self.__field_info, None) 
1930          yield ('info2', self.__field_info2, None) 
1931          yield ('strings', self.__field_strings, None) 
1932          yield ('num1', self.__field_num1, None) 
1933          yield ('num2', self.__field_num2, None) 
1934          yield ('nfiles', self.__field_nfiles, None) 
1935          yield ('num4', self.__field_num4, None) 
1936   
1937   
1938   
1939   
1940 -class _gen_p_samsungspha620_134(BaseProtogenClass): 
1941      'Anonymous inner class' 
1942      __fields=['zeros', 'sixtyfour'] 
1943   
1944 -    def __init__(self, *args, **kwargs): 
1945          dict={} 
1946          # What was supplied to this function 
1947          dict.update(kwargs) 
1948          # Parent constructor 
1949          super(_gen_p_samsungspha620_134,self).__init__(**dict) 
1950          if self.__class__ is _gen_p_samsungspha620_134: 
1951              self._update(args,dict) 
1952   
1953   
1954 -    def getfields(self): 
1955          return self.__fields 
1956   
1957   
1958 -    def _update(self, args, kwargs): 
1959          super(_gen_p_samsungspha620_134,self)._update(args,kwargs) 
1960          keys=kwargs.keys() 
1961          for key in keys: 
1962              if key in self.__fields: 
1963                  setattr(self, key, kwargs[key]) 
1964                  del kwargs[key] 
1965          # Were any unrecognized kwargs passed in? 
1966          if __debug__: 
1967              self._complainaboutunusedargs(_gen_p_samsungspha620_134,kwargs) 
1968          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1969          # Make all P fields that haven't already been constructed 
1970   
1971   
1972 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1973          'Writes this packet to the supplied buffer' 
1974          self._bufferstartoffset=buf.getcurrentoffset() 
1975          self.__field_zeros.writetobuffer(buf) 
1976          self.__field_sixtyfour.writetobuffer(buf) 
1977          self._bufferendoffset=buf.getcurrentoffset() 
1978          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1979   
1980   
1981 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1982          'Reads this packet from the supplied buffer' 
1983          self._bufferstartoffset=buf.getcurrentoffset() 
1984          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1985          self.__field_zeros=UINT(**{'sizeinbytes': 4}) 
1986          self.__field_zeros.readfrombuffer(buf) 
1987          self.__field_sixtyfour=UINT(**{'sizeinbytes': 2}) 
1988          self.__field_sixtyfour.readfrombuffer(buf) 
1989          self._bufferendoffset=buf.getcurrentoffset() 
1990   
1991   
1992 -    def __getfield_zeros(self): 
1993          return self.__field_zeros.getvalue() 
1994   
1995 -    def __setfield_zeros(self, value): 
1996          if isinstance(value,UINT): 
1997              self.__field_zeros=value 
1998          else: 
1999              self.__field_zeros=UINT(value,**{'sizeinbytes': 4}) 
2000   
2001 -    def __delfield_zeros(self): del self.__field_zeros 
2002   
2003      zeros=property(__getfield_zeros, __setfield_zeros, __delfield_zeros, None) 
2004   
2005 -    def __getfield_sixtyfour(self): 
2006          return self.__field_sixtyfour.getvalue() 
2007   
2008 -    def __setfield_sixtyfour(self, value): 
2009          if isinstance(value,UINT): 
2010              self.__field_sixtyfour=value 
2011          else: 
2012              self.__field_sixtyfour=UINT(value,**{'sizeinbytes': 2}) 
2013   
2014 -    def __delfield_sixtyfour(self): del self.__field_sixtyfour 
2015   
2016      sixtyfour=property(__getfield_sixtyfour, __setfield_sixtyfour, __delfield_sixtyfour, None) 
2017   
2018 -    def iscontainer(self): 
2019          return True 
2020   
2021 -    def containerelements(self): 
2022          yield ('zeros', self.__field_zeros, None) 
2023          yield ('sixtyfour', self.__field_sixtyfour, None) 
2024   
2025   
2026   
2027   
2028 -class _gen_p_samsungspha620_137(BaseProtogenClass): 
2029      'Anonymous inner class' 
2030      __fields=['dir_ptr', 'num2', 'name_ptr', 'version_ptr', 'vendor_ptr', 'downloaddomain_ptr', 'num7', 'num8', 'num9', 'filetype', 'mimetype_ptr', 'num12', 'num13', 'num14', 'num15', 'num16', 'num17'] 
2031   
2032 -    def __init__(self, *args, **kwargs): 
2033          dict={} 
2034          # What was supplied to this function 
2035          dict.update(kwargs) 
2036          # Parent constructor 
2037          super(_gen_p_samsungspha620_137,self).__init__(**dict) 
2038          if self.__class__ is _gen_p_samsungspha620_137: 
2039              self._update(args,dict) 
2040   
2041   
2042 -    def getfields(self): 
2043          return self.__fields 
2044   
2045   
2046 -    def _update(self, args, kwargs): 
2047          super(_gen_p_samsungspha620_137,self)._update(args,kwargs) 
2048          keys=kwargs.keys() 
2049          for key in keys: 
2050              if key in self.__fields: 
2051                  setattr(self, key, kwargs[key]) 
2052                  del kwargs[key] 
2053          # Were any unrecognized kwargs passed in? 
2054          if __debug__: 
2055              self._complainaboutunusedargs(_gen_p_samsungspha620_137,kwargs) 
2056          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2057          # Make all P fields that haven't already been constructed 
2058   
2059   
2060 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2061          'Writes this packet to the supplied buffer' 
2062          self._bufferstartoffset=buf.getcurrentoffset() 
2063          self.__field_dir_ptr.writetobuffer(buf) 
2064          self.__field_num2.writetobuffer(buf) 
2065          self.__field_name_ptr.writetobuffer(buf) 
2066          self.__field_version_ptr.writetobuffer(buf) 
2067          self.__field_vendor_ptr.writetobuffer(buf) 
2068          self.__field_downloaddomain_ptr.writetobuffer(buf) 
2069          self.__field_num7.writetobuffer(buf) 
2070          self.__field_num8.writetobuffer(buf) 
2071          self.__field_num9.writetobuffer(buf) 
2072          self.__field_filetype.writetobuffer(buf) 
2073          self.__field_mimetype_ptr.writetobuffer(buf) 
2074          self.__field_num12.writetobuffer(buf) 
2075          self.__field_num13.writetobuffer(buf) 
2076          self.__field_num14.writetobuffer(buf) 
2077          self.__field_num15.writetobuffer(buf) 
2078          self.__field_num16.writetobuffer(buf) 
2079          self.__field_num17.writetobuffer(buf) 
2080          self._bufferendoffset=buf.getcurrentoffset() 
2081          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2082   
2083   
2084 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2085          'Reads this packet from the supplied buffer' 
2086          self._bufferstartoffset=buf.getcurrentoffset() 
2087          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2088          self.__field_dir_ptr=UINT(**{'sizeinbytes': 2}) 
2089          self.__field_dir_ptr.readfrombuffer(buf) 
2090          self.__field_num2=UINT(**{'sizeinbytes': 2}) 
2091          self.__field_num2.readfrombuffer(buf) 
2092          self.__field_name_ptr=UINT(**{'sizeinbytes': 2}) 
2093          self.__field_name_ptr.readfrombuffer(buf) 
2094          self.__field_version_ptr=UINT(**{'sizeinbytes': 2}) 
2095          self.__field_version_ptr.readfrombuffer(buf) 
2096          self.__field_vendor_ptr=UINT(**{'sizeinbytes': 2}) 
2097          self.__field_vendor_ptr.readfrombuffer(buf) 
2098          self.__field_downloaddomain_ptr=UINT(**{'sizeinbytes': 2}) 
2099          self.__field_downloaddomain_ptr.readfrombuffer(buf) 
2100          self.__field_num7=UINT(**{'sizeinbytes': 2}) 
2101          self.__field_num7.readfrombuffer(buf) 
2102          self.__field_num8=UINT(**{'sizeinbytes': 2}) 
2103          self.__field_num8.readfrombuffer(buf) 
2104          self.__field_num9=UINT(**{'sizeinbytes': 4}) 
2105          self.__field_num9.readfrombuffer(buf) 
2106          self.__field_filetype=UINT(**{'sizeinbytes': 2}) 
2107          self.__field_filetype.readfrombuffer(buf) 
2108          self.__field_mimetype_ptr=UINT(**{'sizeinbytes': 2}) 
2109          self.__field_mimetype_ptr.readfrombuffer(buf) 
2110          self.__field_num12=UINT(**{'sizeinbytes': 2}) 
2111          self.__field_num12.readfrombuffer(buf) 
2112          self.__field_num13=UINT(**{'sizeinbytes': 2}) 
2113          self.__field_num13.readfrombuffer(buf) 
2114          self.__field_num14=UINT(**{'sizeinbytes': 2}) 
2115          self.__field_num14.readfrombuffer(buf) 
2116          self.__field_num15=UINT(**{'sizeinbytes': 2}) 
2117          self.__field_num15.readfrombuffer(buf) 
2118          self.__field_num16=UINT(**{'sizeinbytes': 2}) 
2119          self.__field_num16.readfrombuffer(buf) 
2120          self.__field_num17=UINT(**{'sizeinbytes': 2}) 
2121          self.__field_num17.readfrombuffer(buf) 
2122          self._bufferendoffset=buf.getcurrentoffset() 
2123   
2124   
2125 -    def __getfield_dir_ptr(self): 
2126          return self.__field_dir_ptr.getvalue() 
2127   
2128 -    def __setfield_dir_ptr(self, value): 
2129          if isinstance(value,UINT): 
2130              self.__field_dir_ptr=value 
2131          else: 
2132              self.__field_dir_ptr=UINT(value,**{'sizeinbytes': 2}) 
2133   
2134 -    def __delfield_dir_ptr(self): del self.__field_dir_ptr 
2135   
2136      dir_ptr=property(__getfield_dir_ptr, __setfield_dir_ptr, __delfield_dir_ptr, None) 
2137   
2138 -    def __getfield_num2(self): 
2139          return self.__field_num2.getvalue() 
2140   
2141 -    def __setfield_num2(self, value): 
2142          if isinstance(value,UINT): 
2143              self.__field_num2=value 
2144          else: 
2145              self.__field_num2=UINT(value,**{'sizeinbytes': 2}) 
2146   
2147 -    def __delfield_num2(self): del self.__field_num2 
2148   
2149      num2=property(__getfield_num2, __setfield_num2, __delfield_num2, None) 
2150   
2151 -    def __getfield_name_ptr(self): 
2152          return self.__field_name_ptr.getvalue() 
2153   
2154 -    def __setfield_name_ptr(self, value): 
2155          if isinstance(value,UINT): 
2156              self.__field_name_ptr=value 
2157          else: 
2158              self.__field_name_ptr=UINT(value,**{'sizeinbytes': 2}) 
2159   
2160 -    def __delfield_name_ptr(self): del self.__field_name_ptr 
2161   
2162      name_ptr=property(__getfield_name_ptr, __setfield_name_ptr, __delfield_name_ptr, None) 
2163   
2164 -    def __getfield_version_ptr(self): 
2165          return self.__field_version_ptr.getvalue() 
2166   
2167 -    def __setfield_version_ptr(self, value): 
2168          if isinstance(value,UINT): 
2169              self.__field_version_ptr=value 
2170          else: 
2171              self.__field_version_ptr=UINT(value,**{'sizeinbytes': 2}) 
2172   
2173 -    def __delfield_version_ptr(self): del self.__field_version_ptr 
2174   
2175      version_ptr=property(__getfield_version_ptr, __setfield_version_ptr, __delfield_version_ptr, None) 
2176   
2177 -    def __getfield_vendor_ptr(self): 
2178          return self.__field_vendor_ptr.getvalue() 
2179   
2180 -    def __setfield_vendor_ptr(self, value): 
2181          if isinstance(value,UINT): 
2182              self.__field_vendor_ptr=value 
2183          else: 
2184              self.__field_vendor_ptr=UINT(value,**{'sizeinbytes': 2}) 
2185   
2186 -    def __delfield_vendor_ptr(self): del self.__field_vendor_ptr 
2187   
2188      vendor_ptr=property(__getfield_vendor_ptr, __setfield_vendor_ptr, __delfield_vendor_ptr, None) 
2189   
2190 -    def __getfield_downloaddomain_ptr(self): 
2191          return self.__field_downloaddomain_ptr.getvalue() 
2192   
2193 -    def __setfield_downloaddomain_ptr(self, value): 
2194          if isinstance(value,UINT): 
2195              self.__field_downloaddomain_ptr=value 
2196          else: 
2197              self.__field_downloaddomain_ptr=UINT(value,**{'sizeinbytes': 2}) 
2198   
2199 -    def __delfield_downloaddomain_ptr(self): del self.__field_downloaddomain_ptr 
2200   
2201      downloaddomain_ptr=property(__getfield_downloaddomain_ptr, __setfield_downloaddomain_ptr, __delfield_downloaddomain_ptr, None) 
2202   
2203 -    def __getfield_num7(self): 
2204          return self.__field_num7.getvalue() 
2205   
2206 -    def __setfield_num7(self, value): 
2207          if isinstance(value,UINT): 
2208              self.__field_num7=value 
2209          else: 
2210              self.__field_num7=UINT(value,**{'sizeinbytes': 2}) 
2211   
2212 -    def __delfield_num7(self): del self.__field_num7 
2213   
2214      num7=property(__getfield_num7, __setfield_num7, __delfield_num7, None) 
2215   
2216 -    def __getfield_num8(self): 
2217          return self.__field_num8.getvalue() 
2218   
2219 -    def __setfield_num8(self, value): 
2220          if isinstance(value,UINT): 
2221              self.__field_num8=value 
2222          else: 
2223              self.__field_num8=UINT(value,**{'sizeinbytes': 2}) 
2224   
2225 -    def __delfield_num8(self): del self.__field_num8 
2226   
2227      num8=property(__getfield_num8, __setfield_num8, __delfield_num8, None) 
2228   
2229 -    def __getfield_num9(self): 
2230          return self.__field_num9.getvalue() 
2231   
2232 -    def __setfield_num9(self, value): 
2233          if isinstance(value,UINT): 
2234              self.__field_num9=value 
2235          else: 
2236              self.__field_num9=UINT(value,**{'sizeinbytes': 4}) 
2237   
2238 -    def __delfield_num9(self): del self.__field_num9 
2239   
2240      num9=property(__getfield_num9, __setfield_num9, __delfield_num9, None) 
2241   
2242 -    def __getfield_filetype(self): 
2243          return self.__field_filetype.getvalue() 
2244   
2245 -    def __setfield_filetype(self, value): 
2246          if isinstance(value,UINT): 
2247              self.__field_filetype=value 
2248          else: 
2249              self.__field_filetype=UINT(value,**{'sizeinbytes': 2}) 
2250   
2251 -    def __delfield_filetype(self): del self.__field_filetype 
2252   
2253      filetype=property(__getfield_filetype, __setfield_filetype, __delfield_filetype, "12: Ringer, 13 Screen Saver, 15 Apps") 
2254   
2255 -    def __getfield_mimetype_ptr(self): 
2256          return self.__field_mimetype_ptr.getvalue() 
2257   
2258 -    def __setfield_mimetype_ptr(self, value): 
2259          if isinstance(value,UINT): 
2260              self.__field_mimetype_ptr=value 
2261          else: 
2262              self.__field_mimetype_ptr=UINT(value,**{'sizeinbytes': 2}) 
2263   
2264 -    def __delfield_mimetype_ptr(self): del self.__field_mimetype_ptr 
2265   
2266      mimetype_ptr=property(__getfield_mimetype_ptr, __setfield_mimetype_ptr, __delfield_mimetype_ptr, None) 
2267   
2268 -    def __getfield_num12(self): 
2269          return self.__field_num12.getvalue() 
2270   
2271 -    def __setfield_num12(self, value): 
2272          if isinstance(value,UINT): 
2273              self.__field_num12=value 
2274          else: 
2275              self.__field_num12=UINT(value,**{'sizeinbytes': 2}) 
2276   
2277 -    def __delfield_num12(self): del self.__field_num12 
2278   
2279      num12=property(__getfield_num12, __setfield_num12, __delfield_num12, None) 
2280   
2281 -    def __getfield_num13(self): 
2282          return self.__field_num13.getvalue() 
2283   
2284 -    def __setfield_num13(self, value): 
2285          if isinstance(value,UINT): 
2286              self.__field_num13=value 
2287          else: 
2288              self.__field_num13=UINT(value,**{'sizeinbytes': 2}) 
2289   
2290 -    def __delfield_num13(self): del self.__field_num13 
2291   
2292      num13=property(__getfield_num13, __setfield_num13, __delfield_num13, None) 
2293   
2294 -    def __getfield_num14(self): 
2295          return self.__field_num14.getvalue() 
2296   
2297 -    def __setfield_num14(self, value): 
2298          if isinstance(value,UINT): 
2299              self.__field_num14=value 
2300          else: 
2301              self.__field_num14=UINT(value,**{'sizeinbytes': 2}) 
2302   
2303 -    def __delfield_num14(self): del self.__field_num14 
2304   
2305      num14=property(__getfield_num14, __setfield_num14, __delfield_num14, None) 
2306   
2307 -    def __getfield_num15(self): 
2308          return self.__field_num15.getvalue() 
2309   
2310 -    def __setfield_num15(self, value): 
2311          if isinstance(value,UINT): 
2312              self.__field_num15=value 
2313          else: 
2314              self.__field_num15=UINT(value,**{'sizeinbytes': 2}) 
2315   
2316 -    def __delfield_num15(self): del self.__field_num15 
2317   
2318      num15=property(__getfield_num15, __setfield_num15, __delfield_num15, None) 
2319   
2320 -    def __getfield_num16(self): 
2321          return self.__field_num16.getvalue() 
2322   
2323 -    def __setfield_num16(self, value): 
2324          if isinstance(value,UINT): 
2325              self.__field_num16=value 
2326          else: 
2327              self.__field_num16=UINT(value,**{'sizeinbytes': 2}) 
2328   
2329 -    def __delfield_num16(self): del self.__field_num16 
2330   
2331      num16=property(__getfield_num16, __setfield_num16, __delfield_num16, None) 
2332   
2333 -    def __getfield_num17(self): 
2334          return self.__field_num17.getvalue() 
2335   
2336 -    def __setfield_num17(self, value): 
2337          if isinstance(value,UINT): 
2338              self.__field_num17=value 
2339          else: 
2340              self.__field_num17=UINT(value,**{'sizeinbytes': 2}) 
2341   
2342 -    def __delfield_num17(self): del self.__field_num17 
2343   
2344      num17=property(__getfield_num17, __setfield_num17, __delfield_num17, None) 
2345   
2346 -    def iscontainer(self): 
2347          return True 
2348   
2349 -    def containerelements(self): 
2350          yield ('dir_ptr', self.__field_dir_ptr, None) 
2351          yield ('num2', self.__field_num2, None) 
2352          yield ('name_ptr', self.__field_name_ptr, None) 
2353          yield ('version_ptr', self.__field_version_ptr, None) 
2354          yield ('vendor_ptr', self.__field_vendor_ptr, None) 
2355          yield ('downloaddomain_ptr', self.__field_downloaddomain_ptr, None) 
2356          yield ('num7', self.__field_num7, None) 
2357          yield ('num8', self.__field_num8, None) 
2358          yield ('num9', self.__field_num9, None) 
2359          yield ('filetype', self.__field_filetype, "12: Ringer, 13 Screen Saver, 15 Apps") 
2360          yield ('mimetype_ptr', self.__field_mimetype_ptr, None) 
2361          yield ('num12', self.__field_num12, None) 
2362          yield ('num13', self.__field_num13, None) 
2363          yield ('num14', self.__field_num14, None) 
2364          yield ('num15', self.__field_num15, None) 
2365          yield ('num16', self.__field_num16, None) 
2366          yield ('num17', self.__field_num17, None) 
2367   
2368   
2369   
2370   
2371 -class _gen_p_samsungspha620_155(BaseProtogenClass): 
2372      'Anonymous inner class' 
2373      __fields=['val1', 'val2', 'val3', 'val4', 'val5', 'val6', 'val7', 'val8', 'val9', 'val10'] 
2374   
2375 -    def __init__(self, *args, **kwargs): 
2376          dict={} 
2377          # What was supplied to this function 
2378          dict.update(kwargs) 
2379          # Parent constructor 
2380          super(_gen_p_samsungspha620_155,self).__init__(**dict) 
2381          if self.__class__ is _gen_p_samsungspha620_155: 
2382              self._update(args,dict) 
2383   
2384   
2385 -    def getfields(self): 
2386          return self.__fields 
2387   
2388   
2389 -    def _update(self, args, kwargs): 
2390          super(_gen_p_samsungspha620_155,self)._update(args,kwargs) 
2391          keys=kwargs.keys() 
2392          for key in keys: 
2393              if key in self.__fields: 
2394                  setattr(self, key, kwargs[key]) 
2395                  del kwargs[key] 
2396          # Were any unrecognized kwargs passed in? 
2397          if __debug__: 
2398              self._complainaboutunusedargs(_gen_p_samsungspha620_155,kwargs) 
2399          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2400          # Make all P fields that haven't already been constructed 
2401   
2402   
2403 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2404          'Writes this packet to the supplied buffer' 
2405          self._bufferstartoffset=buf.getcurrentoffset() 
2406          self.__field_val1.writetobuffer(buf) 
2407          self.__field_val2.writetobuffer(buf) 
2408          self.__field_val3.writetobuffer(buf) 
2409          self.__field_val4.writetobuffer(buf) 
2410          self.__field_val5.writetobuffer(buf) 
2411          self.__field_val6.writetobuffer(buf) 
2412          self.__field_val7.writetobuffer(buf) 
2413          self.__field_val8.writetobuffer(buf) 
2414          self.__field_val9.writetobuffer(buf) 
2415          self.__field_val10.writetobuffer(buf) 
2416          self._bufferendoffset=buf.getcurrentoffset() 
2417          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2418   
2419   
2420 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2421          'Reads this packet from the supplied buffer' 
2422          self._bufferstartoffset=buf.getcurrentoffset() 
2423          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2424          self.__field_val1=UINT(**{'sizeinbytes': 2}) 
2425          self.__field_val1.readfrombuffer(buf) 
2426          self.__field_val2=UINT(**{'sizeinbytes': 2}) 
2427          self.__field_val2.readfrombuffer(buf) 
2428          self.__field_val3=UINT(**{'sizeinbytes': 2}) 
2429          self.__field_val3.readfrombuffer(buf) 
2430          self.__field_val4=UINT(**{'sizeinbytes': 2}) 
2431          self.__field_val4.readfrombuffer(buf) 
2432          self.__field_val5=UINT(**{'sizeinbytes': 2}) 
2433          self.__field_val5.readfrombuffer(buf) 
2434          self.__field_val6=UINT(**{'sizeinbytes': 2}) 
2435          self.__field_val6.readfrombuffer(buf) 
2436          self.__field_val7=UINT(**{'sizeinbytes': 2}) 
2437          self.__field_val7.readfrombuffer(buf) 
2438          self.__field_val8=UINT(**{'sizeinbytes': 2}) 
2439          self.__field_val8.readfrombuffer(buf) 
2440          self.__field_val9=UINT(**{'sizeinbytes': 2}) 
2441          self.__field_val9.readfrombuffer(buf) 
2442          self.__field_val10=UINT(**{'sizeinbytes': 2}) 
2443          self.__field_val10.readfrombuffer(buf) 
2444          self._bufferendoffset=buf.getcurrentoffset() 
2445   
2446   
2447 -    def __getfield_val1(self): 
2448          return self.__field_val1.getvalue() 
2449   
2450 -    def __setfield_val1(self, value): 
2451          if isinstance(value,UINT): 
2452              self.__field_val1=value 
2453          else: 
2454              self.__field_val1=UINT(value,**{'sizeinbytes': 2}) 
2455   
2456 -    def __delfield_val1(self): del self.__field_val1 
2457   
2458      val1=property(__getfield_val1, __setfield_val1, __delfield_val1, None) 
2459   
2460 -    def __getfield_val2(self): 
2461          return self.__field_val2.getvalue() 
2462   
2463 -    def __setfield_val2(self, value): 
2464          if isinstance(value,UINT): 
2465              self.__field_val2=value 
2466          else: 
2467              self.__field_val2=UINT(value,**{'sizeinbytes': 2}) 
2468   
2469 -    def __delfield_val2(self): del self.__field_val2 
2470   
2471      val2=property(__getfield_val2, __setfield_val2, __delfield_val2, None) 
2472   
2473 -    def __getfield_val3(self): 
2474          return self.__field_val3.getvalue() 
2475   
2476 -    def __setfield_val3(self, value): 
2477          if isinstance(value,UINT): 
2478              self.__field_val3=value 
2479          else: 
2480              self.__field_val3=UINT(value,**{'sizeinbytes': 2}) 
2481   
2482 -    def __delfield_val3(self): del self.__field_val3 
2483   
2484      val3=property(__getfield_val3, __setfield_val3, __delfield_val3, None) 
2485   
2486 -    def __getfield_val4(self): 
2487          return self.__field_val4.getvalue() 
2488   
2489 -    def __setfield_val4(self, value): 
2490          if isinstance(value,UINT): 
2491              self.__field_val4=value 
2492          else: 
2493              self.__field_val4=UINT(value,**{'sizeinbytes': 2}) 
2494   
2495 -    def __delfield_val4(self): del self.__field_val4 
2496   
2497      val4=property(__getfield_val4, __setfield_val4, __delfield_val4, None) 
2498   
2499 -    def __getfield_val5(self): 
2500          return self.__field_val5.getvalue() 
2501   
2502 -    def __setfield_val5(self, value): 
2503          if isinstance(value,UINT): 
2504              self.__field_val5=value 
2505          else: 
2506              self.__field_val5=UINT(value,**{'sizeinbytes': 2}) 
2507   
2508 -    def __delfield_val5(self): del self.__field_val5 
2509   
2510      val5=property(__getfield_val5, __setfield_val5, __delfield_val5, None) 
2511   
2512 -    def __getfield_val6(self): 
2513          return self.__field_val6.getvalue() 
2514   
2515 -    def __setfield_val6(self, value): 
2516          if isinstance(value,UINT): 
2517              self.__field_val6=value 
2518          else: 
2519              self.__field_val6=UINT(value,**{'sizeinbytes': 2}) 
2520   
2521 -    def __delfield_val6(self): del self.__field_val6 
2522   
2523      val6=property(__getfield_val6, __setfield_val6, __delfield_val6, None) 
2524   
2525 -    def __getfield_val7(self): 
2526          return self.__field_val7.getvalue() 
2527   
2528 -    def __setfield_val7(self, value): 
2529          if isinstance(value,UINT): 
2530              self.__field_val7=value 
2531          else: 
2532              self.__field_val7=UINT(value,**{'sizeinbytes': 2}) 
2533   
2534 -    def __delfield_val7(self): del self.__field_val7 
2535   
2536      val7=property(__getfield_val7, __setfield_val7, __delfield_val7, None) 
2537   
2538 -    def __getfield_val8(self): 
2539          return self.__field_val8.getvalue() 
2540   
2541 -    def __setfield_val8(self, value): 
2542          if isinstance(value,UINT): 
2543              self.__field_val8=value 
2544          else: 
2545              self.__field_val8=UINT(value,**{'sizeinbytes': 2}) 
2546   
2547 -    def __delfield_val8(self): del self.__field_val8 
2548   
2549      val8=property(__getfield_val8, __setfield_val8, __delfield_val8, None) 
2550   
2551 -    def __getfield_val9(self): 
2552          return self.__field_val9.getvalue() 
2553   
2554 -    def __setfield_val9(self, value): 
2555          if isinstance(value,UINT): 
2556              self.__field_val9=value 
2557          else: 
2558              self.__field_val9=UINT(value,**{'sizeinbytes': 2}) 
2559   
2560 -    def __delfield_val9(self): del self.__field_val9 
2561   
2562      val9=property(__getfield_val9, __setfield_val9, __delfield_val9, None) 
2563   
2564 -    def __getfield_val10(self): 
2565          return self.__field_val10.getvalue() 
2566   
2567 -    def __setfield_val10(self, value): 
2568          if isinstance(value,UINT): 
2569              self.__field_val10=value 
2570          else: 
2571              self.__field_val10=UINT(value,**{'sizeinbytes': 2}) 
2572   
2573 -    def __delfield_val10(self): del self.__field_val10 
2574   
2575      val10=property(__getfield_val10, __setfield_val10, __delfield_val10, None) 
2576   
2577 -    def iscontainer(self): 
2578          return True 
2579   
2580 -    def containerelements(self): 
2581          yield ('val1', self.__field_val1, None) 
2582          yield ('val2', self.__field_val2, None) 
2583          yield ('val3', self.__field_val3, None) 
2584          yield ('val4', self.__field_val4, None) 
2585          yield ('val5', self.__field_val5, None) 
2586          yield ('val6', self.__field_val6, None) 
2587          yield ('val7', self.__field_val7, None) 
2588          yield ('val8', self.__field_val8, None) 
2589          yield ('val9', self.__field_val9, None) 
2590          yield ('val10', self.__field_val10, None) 
2591