Source Code for Module phones.p_lglg6200

   1  # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE 
   2   
   3  """Various descriptions of data specific to LG 6200 (Sprint)""" 
   4   
   5  import re 
   6   
   7  from prototypes import * 
   8  from prototypeslg import * 
   9   
  10  # Make all lg stuff available in this module as well 
  11  from p_lg import * 
  12  # very similar to the pm225 
  13  from p_lgpm225 import * 
  14   
  15   
  16  # We use LSB for all integer like fields 
  17  UINT=UINTlsb 
  18  BOOL=BOOLlsb 
  19   
  20  NUMSPEEDDIALS=99 
  21  FIRSTSPEEDDIAL=1 
  22  LASTSPEEDDIAL=99 
  23  NUMPHONEBOOKENTRIES=200 
  24  MEMOLENGTH=33 
  25   
  26  NORINGTONE=0 
  27  NOMSGRINGTONE=0 
  28  NOWALLPAPER=0 
  29   
  30  NUMEMAILS=3 
  31  NUMPHONENUMBERS=5 
  32   
  33  SMS_CANNED_MAX_ITEMS=40 
  34  SMS_CANNED_MAX_LENGTH=104 
  35  SMS_CANNED_FILENAME="sms/canned_msg.dat" 
  36  SMS_PATTERNS={'Inbox': re.compile(r"^.*/inbox[0-9][0-9][0-9]\.dat$"), 
  37               'Sent': re.compile(r"^.*/outbox[0-9][0-9][0-9]\.dat$"), 
  38               'Saved': re.compile(r"^.*/sf[0-9][0-9]\.dat$"), 
  39               } 
  40   
  41  numbertypetab=( 'cell', 'home', 'office', 'fax', 'pager' ) 
  42   
  43  # Text Memo const 
  44  text_memo_file='sch/memo.dat' 
  45  content_file_name='ams/contentInfo' 
  46  content_count_file_name='ams/realContent' 
  47   
  48  media_directory='ams' 
  49  ringerindex='setas/amsRingerIndex.map' 
  50  imageindex='setas/amsImageIndex.map' 
  51  ringerconst=2 
  52  imageconst=3 
  53  max_ringers=100 
  54  max_images=100 
  55   
  56  phonebook_media='pim/pbookcontact.dat' 
  57   
  58  # Calendar parameters 
  59  NUMCALENDARENTRIES=300  # ?? for VX4400 
  60  CAL_REP_NONE=0x10 
  61  CAL_REP_DAILY=0x11 
  62  CAL_REP_MONFRI=0x12 
  63  CAL_REP_WEEKLY=0x13 
  64  CAL_REP_MONTHLY=0x14 
  65  CAL_REP_YEARLY=0x15 
  66  CAL_DOW_SUN=0x0800 
  67  CAL_DOW_MON=0x0400 
  68  CAL_DOW_TUE=0x0200 
  69  CAL_DOW_WED=0x0100 
  70  CAL_DOW_THU=0x0080 
  71  CAL_DOW_FRI=0x0040 
  72  CAL_DOW_SAT=0x0020 
  73  CAL_DOW_EXCEPTIONS=0x0010 
  74  CAL_REMINDER_NONE=0 
  75  CAL_REMINDER_ONTIME=1 
  76  CAL_REMINDER_5MIN=2 
  77  CAL_REMINDER_10MIN=3 
  78  CAL_REMINDER_1HOUR=4 
  79  CAL_REMINDER_1DAY=5 
  80  CAL_REMINDER_2DAYS=6 
  81  CAL_REPEAT_DATE=(2100, 12, 31) 
  82   
  83  cal_dir='sch' 
  84  cal_data_file_name='sch/schedule.dat' 
  85  cal_exception_file_name='sch/schexception.dat' 
  86  cal_has_voice_id=False 
  87   
  88  PHONE_ENCODING='iso8859_1' 
  89   
  90 -class pbreadentryresponse(BaseProtogenClass): 
  91      "Results of reading one entry" 
  92      __fields=['header', 'entry'] 
  93   
  94 -    def __init__(self, *args, **kwargs): 
  95          dict={} 
  96          # What was supplied to this function 
  97          dict.update(kwargs) 
  98          # Parent constructor 
  99          super(pbreadentryresponse,self).__init__(**dict) 
 100          if self.__class__ is pbreadentryresponse: 
 101              self._update(args,dict) 
 102   
 103   
 104 -    def getfields(self): 
 105          return self.__fields 
 106   
 107   
 108 -    def _update(self, args, kwargs): 
 109          super(pbreadentryresponse,self)._update(args,kwargs) 
 110          keys=kwargs.keys() 
 111          for key in keys: 
 112              if key in self.__fields: 
 113                  setattr(self, key, kwargs[key]) 
 114                  del kwargs[key] 
 115          # Were any unrecognized kwargs passed in? 
 116          if __debug__: 
 117              self._complainaboutunusedargs(pbreadentryresponse,kwargs) 
 118          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 119          # Make all P fields that haven't already been constructed 
 120   
 121   
 122 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 123          'Writes this packet to the supplied buffer' 
 124          self._bufferstartoffset=buf.getcurrentoffset() 
 125          self.__field_header.writetobuffer(buf) 
 126          self.__field_entry.writetobuffer(buf) 
 127          self._bufferendoffset=buf.getcurrentoffset() 
 128          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 129   
 130   
 131 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 132          'Reads this packet from the supplied buffer' 
 133          self._bufferstartoffset=buf.getcurrentoffset() 
 134          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 135          self.__field_header=pbheader() 
 136          self.__field_header.readfrombuffer(buf) 
 137          self.__field_entry=pbentry() 
 138          self.__field_entry.readfrombuffer(buf) 
 139          self._bufferendoffset=buf.getcurrentoffset() 
 140   
 141   
 142 -    def __getfield_header(self): 
 143          return self.__field_header.getvalue() 
 144   
 145 -    def __setfield_header(self, value): 
 146          if isinstance(value,pbheader): 
 147              self.__field_header=value 
 148          else: 
 149              self.__field_header=pbheader(value,) 
 150   
 151 -    def __delfield_header(self): del self.__field_header 
 152   
 153      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
 154   
 155 -    def __getfield_entry(self): 
 156          return self.__field_entry.getvalue() 
 157   
 158 -    def __setfield_entry(self, value): 
 159          if isinstance(value,pbentry): 
 160              self.__field_entry=value 
 161          else: 
 162              self.__field_entry=pbentry(value,) 
 163   
 164 -    def __delfield_entry(self): del self.__field_entry 
 165   
 166      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
 167   
 168 -    def iscontainer(self): 
 169          return True 
 170   
 171 -    def containerelements(self): 
 172          yield ('header', self.__field_header, None) 
 173          yield ('entry', self.__field_entry, None) 
 174   
 175   
 176   
 177   
 178 -class pbupdateentryrequest(BaseProtogenClass): 
 179      __fields=['header', 'entry'] 
 180   
 181 -    def __init__(self, *args, **kwargs): 
 182          dict={} 
 183          # What was supplied to this function 
 184          dict.update(kwargs) 
 185          # Parent constructor 
 186          super(pbupdateentryrequest,self).__init__(**dict) 
 187          if self.__class__ is pbupdateentryrequest: 
 188              self._update(args,dict) 
 189   
 190   
 191 -    def getfields(self): 
 192          return self.__fields 
 193   
 194   
 195 -    def _update(self, args, kwargs): 
 196          super(pbupdateentryrequest,self)._update(args,kwargs) 
 197          keys=kwargs.keys() 
 198          for key in keys: 
 199              if key in self.__fields: 
 200                  setattr(self, key, kwargs[key]) 
 201                  del kwargs[key] 
 202          # Were any unrecognized kwargs passed in? 
 203          if __debug__: 
 204              self._complainaboutunusedargs(pbupdateentryrequest,kwargs) 
 205          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 206          # Make all P fields that haven't already been constructed 
 207   
 208   
 209 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 210          'Writes this packet to the supplied buffer' 
 211          self._bufferstartoffset=buf.getcurrentoffset() 
 212          try: self.__field_header 
 213          except: 
 214              self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01}) 
 215          self.__field_header.writetobuffer(buf) 
 216          self.__field_entry.writetobuffer(buf) 
 217          self._bufferendoffset=buf.getcurrentoffset() 
 218          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 219   
 220   
 221 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 222          'Reads this packet from the supplied buffer' 
 223          self._bufferstartoffset=buf.getcurrentoffset() 
 224          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 225          self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01}) 
 226          self.__field_header.readfrombuffer(buf) 
 227          self.__field_entry=pbentry() 
 228          self.__field_entry.readfrombuffer(buf) 
 229          self._bufferendoffset=buf.getcurrentoffset() 
 230   
 231   
 232 -    def __getfield_header(self): 
 233          try: self.__field_header 
 234          except: 
 235              self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01}) 
 236          return self.__field_header.getvalue() 
 237   
 238 -    def __setfield_header(self, value): 
 239          if isinstance(value,pbheader): 
 240              self.__field_header=value 
 241          else: 
 242              self.__field_header=pbheader(value,**{'command': 0x04, 'flag': 0x01}) 
 243   
 244 -    def __delfield_header(self): del self.__field_header 
 245   
 246      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
 247   
 248 -    def __getfield_entry(self): 
 249          return self.__field_entry.getvalue() 
 250   
 251 -    def __setfield_entry(self, value): 
 252          if isinstance(value,pbentry): 
 253              self.__field_entry=value 
 254          else: 
 255              self.__field_entry=pbentry(value,) 
 256   
 257 -    def __delfield_entry(self): del self.__field_entry 
 258   
 259      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
 260   
 261 -    def iscontainer(self): 
 262          return True 
 263   
 264 -    def containerelements(self): 
 265          yield ('header', self.__field_header, None) 
 266          yield ('entry', self.__field_entry, None) 
 267   
 268   
 269   
 270   
 271 -class pbappendentryrequest(BaseProtogenClass): 
 272      __fields=['header', 'entry'] 
 273   
 274 -    def __init__(self, *args, **kwargs): 
 275          dict={} 
 276          # What was supplied to this function 
 277          dict.update(kwargs) 
 278          # Parent constructor 
 279          super(pbappendentryrequest,self).__init__(**dict) 
 280          if self.__class__ is pbappendentryrequest: 
 281              self._update(args,dict) 
 282   
 283   
 284 -    def getfields(self): 
 285          return self.__fields 
 286   
 287   
 288 -    def _update(self, args, kwargs): 
 289          super(pbappendentryrequest,self)._update(args,kwargs) 
 290          keys=kwargs.keys() 
 291          for key in keys: 
 292              if key in self.__fields: 
 293                  setattr(self, key, kwargs[key]) 
 294                  del kwargs[key] 
 295          # Were any unrecognized kwargs passed in? 
 296          if __debug__: 
 297              self._complainaboutunusedargs(pbappendentryrequest,kwargs) 
 298          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 299          # Make all P fields that haven't already been constructed 
 300   
 301   
 302 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 303          'Writes this packet to the supplied buffer' 
 304          self._bufferstartoffset=buf.getcurrentoffset() 
 305          try: self.__field_header 
 306          except: 
 307              self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01}) 
 308          self.__field_header.writetobuffer(buf) 
 309          self.__field_entry.writetobuffer(buf) 
 310          self._bufferendoffset=buf.getcurrentoffset() 
 311          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 312   
 313   
 314 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 315          'Reads this packet from the supplied buffer' 
 316          self._bufferstartoffset=buf.getcurrentoffset() 
 317          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 318          self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01}) 
 319          self.__field_header.readfrombuffer(buf) 
 320          self.__field_entry=pbentry() 
 321          self.__field_entry.readfrombuffer(buf) 
 322          self._bufferendoffset=buf.getcurrentoffset() 
 323   
 324   
 325 -    def __getfield_header(self): 
 326          try: self.__field_header 
 327          except: 
 328              self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01}) 
 329          return self.__field_header.getvalue() 
 330   
 331 -    def __setfield_header(self, value): 
 332          if isinstance(value,pbheader): 
 333              self.__field_header=value 
 334          else: 
 335              self.__field_header=pbheader(value,**{'command': 0x03, 'flag': 0x01}) 
 336   
 337 -    def __delfield_header(self): del self.__field_header 
 338   
 339      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
 340   
 341 -    def __getfield_entry(self): 
 342          return self.__field_entry.getvalue() 
 343   
 344 -    def __setfield_entry(self, value): 
 345          if isinstance(value,pbentry): 
 346              self.__field_entry=value 
 347          else: 
 348              self.__field_entry=pbentry(value,) 
 349   
 350 -    def __delfield_entry(self): del self.__field_entry 
 351   
 352      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
 353   
 354 -    def iscontainer(self): 
 355          return True 
 356   
 357 -    def containerelements(self): 
 358          yield ('header', self.__field_header, None) 
 359          yield ('entry', self.__field_entry, None) 
 360   
 361   
 362   
 363   
 364 -class pbentry(BaseProtogenClass): 
 365      __fields=['serial1', 'entrysize', 'entrynumber', 'unknown1', 'name', 'group', 'unknown2', 'secret', 'memo', 'emails', 'url', 'numberspeeds', 'numbertypes', 'numbers', 'EndOfRecord', 'ringtone', 'wallpaper'] 
 366   
 367 -    def __init__(self, *args, **kwargs): 
 368          dict={} 
 369          # What was supplied to this function 
 370          dict.update(kwargs) 
 371          # Parent constructor 
 372          super(pbentry,self).__init__(**dict) 
 373          if self.__class__ is pbentry: 
 374              self._update(args,dict) 
 375   
 376   
 377 -    def getfields(self): 
 378          return self.__fields 
 379   
 380   
 381 -    def _update(self, args, kwargs): 
 382          super(pbentry,self)._update(args,kwargs) 
 383          keys=kwargs.keys() 
 384          for key in keys: 
 385              if key in self.__fields: 
 386                  setattr(self, key, kwargs[key]) 
 387                  del kwargs[key] 
 388          # Were any unrecognized kwargs passed in? 
 389          if __debug__: 
 390              self._complainaboutunusedargs(pbentry,kwargs) 
 391          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 392          # Make all P fields that haven't already been constructed 
 393          try: self.__field_ringtone 
 394          except: 
 395              self.__field_ringtone=UINT(**{'default': 0x600}) 
 396          try: self.__field_wallpaper 
 397          except: 
 398              self.__field_wallpaper=UINT(**{'default': 0x100}) 
 399   
 400   
 401 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 402          'Writes this packet to the supplied buffer' 
 403          self._bufferstartoffset=buf.getcurrentoffset() 
 404          self.__field_serial1.writetobuffer(buf) 
 405          try: self.__field_entrysize 
 406          except: 
 407              self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0x026e}) 
 408          self.__field_entrysize.writetobuffer(buf) 
 409          self.__field_entrynumber.writetobuffer(buf) 
 410          try: self.__field_unknown1 
 411          except: 
 412              self.__field_unknown1=UINT(**{'sizeinbytes': 2, 'default': 0}) 
 413          self.__field_unknown1.writetobuffer(buf) 
 414          self.__field_name.writetobuffer(buf) 
 415          self.__field_group.writetobuffer(buf) 
 416          try: self.__field_unknown2 
 417          except: 
 418              self.__field_unknown2=UINT(**{'sizeinbytes': 2, 'default': 0x10}) 
 419          self.__field_unknown2.writetobuffer(buf) 
 420          self.__field_secret.writetobuffer(buf) 
 421          self.__field_memo.writetobuffer(buf) 
 422          try: self.__field_emails 
 423          except: 
 424              self.__field_emails=LIST(**{'elementclass': _gen_p_lglg6200_129, 'length': NUMEMAILS}) 
 425          self.__field_emails.writetobuffer(buf) 
 426          self.__field_url.writetobuffer(buf) 
 427          try: self.__field_numberspeeds 
 428          except: 
 429              self.__field_numberspeeds=LIST(**{'elementclass': _gen_p_lglg6200_132, 'length': NUMPHONENUMBERS}) 
 430          self.__field_numberspeeds.writetobuffer(buf) 
 431          try: self.__field_numbertypes 
 432          except: 
 433              self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lglg6200_134, 'length': NUMPHONENUMBERS}) 
 434          self.__field_numbertypes.writetobuffer(buf) 
 435          try: self.__field_numbers 
 436          except: 
 437              self.__field_numbers=LIST(**{'elementclass': _gen_p_lglg6200_136, 'length': NUMPHONENUMBERS}) 
 438          self.__field_numbers.writetobuffer(buf) 
 439          try: self.__field_EndOfRecord 
 440          except: 
 441              self.__field_EndOfRecord=UINT(**{'sizeinbytes': 2, 'constant': 0x0278}) 
 442          self.__field_EndOfRecord.writetobuffer(buf) 
 443          self._bufferendoffset=buf.getcurrentoffset() 
 444          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 445   
 446   
 447 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 448          'Reads this packet from the supplied buffer' 
 449          self._bufferstartoffset=buf.getcurrentoffset() 
 450          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 451          self.__field_serial1=UINT(**{'sizeinbytes': 4}) 
 452          self.__field_serial1.readfrombuffer(buf) 
 453          self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0x026e}) 
 454          self.__field_entrysize.readfrombuffer(buf) 
 455          self.__field_entrynumber=UINT(**{'sizeinbytes': 2}) 
 456          self.__field_entrynumber.readfrombuffer(buf) 
 457          self.__field_unknown1=UINT(**{'sizeinbytes': 2, 'default': 0}) 
 458          self.__field_unknown1.readfrombuffer(buf) 
 459          self.__field_name=USTRING(**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
 460          self.__field_name.readfrombuffer(buf) 
 461          self.__field_group=UINT(**{'sizeinbytes': 2}) 
 462          self.__field_group.readfrombuffer(buf) 
 463          self.__field_unknown2=UINT(**{'sizeinbytes': 2, 'default': 0x10}) 
 464          self.__field_unknown2.readfrombuffer(buf) 
 465          self.__field_secret=BOOL(**{'sizeinbytes': 1}) 
 466          self.__field_secret.readfrombuffer(buf) 
 467          self.__field_memo=USTRING(**{'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'sizeinbytes': MEMOLENGTH}) 
 468          self.__field_memo.readfrombuffer(buf) 
 469          self.__field_emails=LIST(**{'elementclass': _gen_p_lglg6200_129, 'length': NUMEMAILS}) 
 470          self.__field_emails.readfrombuffer(buf) 
 471          self.__field_url=USTRING(**{'sizeinbytes': 73, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
 472          self.__field_url.readfrombuffer(buf) 
 473          self.__field_numberspeeds=LIST(**{'elementclass': _gen_p_lglg6200_132, 'length': NUMPHONENUMBERS}) 
 474          self.__field_numberspeeds.readfrombuffer(buf) 
 475          self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lglg6200_134, 'length': NUMPHONENUMBERS}) 
 476          self.__field_numbertypes.readfrombuffer(buf) 
 477          self.__field_numbers=LIST(**{'elementclass': _gen_p_lglg6200_136, 'length': NUMPHONENUMBERS}) 
 478          self.__field_numbers.readfrombuffer(buf) 
 479          self.__field_EndOfRecord=UINT(**{'sizeinbytes': 2, 'constant': 0x0278}) 
 480          self.__field_EndOfRecord.readfrombuffer(buf) 
 481          self._bufferendoffset=buf.getcurrentoffset() 
 482   
 483   
 484 -    def __getfield_serial1(self): 
 485          return self.__field_serial1.getvalue() 
 486   
 487 -    def __setfield_serial1(self, value): 
 488          if isinstance(value,UINT): 
 489              self.__field_serial1=value 
 490          else: 
 491              self.__field_serial1=UINT(value,**{'sizeinbytes': 4}) 
 492   
 493 -    def __delfield_serial1(self): del self.__field_serial1 
 494   
 495      serial1=property(__getfield_serial1, __setfield_serial1, __delfield_serial1, None) 
 496   
 497 -    def __getfield_entrysize(self): 
 498          try: self.__field_entrysize 
 499          except: 
 500              self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0x026e}) 
 501          return self.__field_entrysize.getvalue() 
 502   
 503 -    def __setfield_entrysize(self, value): 
 504          if isinstance(value,UINT): 
 505              self.__field_entrysize=value 
 506          else: 
 507              self.__field_entrysize=UINT(value,**{'sizeinbytes': 2, 'constant': 0x026e}) 
 508   
 509 -    def __delfield_entrysize(self): del self.__field_entrysize 
 510   
 511      entrysize=property(__getfield_entrysize, __setfield_entrysize, __delfield_entrysize, None) 
 512   
 513 -    def __getfield_entrynumber(self): 
 514          return self.__field_entrynumber.getvalue() 
 515   
 516 -    def __setfield_entrynumber(self, value): 
 517          if isinstance(value,UINT): 
 518              self.__field_entrynumber=value 
 519          else: 
 520              self.__field_entrynumber=UINT(value,**{'sizeinbytes': 2}) 
 521   
 522 -    def __delfield_entrynumber(self): del self.__field_entrynumber 
 523   
 524      entrynumber=property(__getfield_entrynumber, __setfield_entrynumber, __delfield_entrynumber, None) 
 525   
 526 -    def __getfield_unknown1(self): 
 527          try: self.__field_unknown1 
 528          except: 
 529              self.__field_unknown1=UINT(**{'sizeinbytes': 2, 'default': 0}) 
 530          return self.__field_unknown1.getvalue() 
 531   
 532 -    def __setfield_unknown1(self, value): 
 533          if isinstance(value,UINT): 
 534              self.__field_unknown1=value 
 535          else: 
 536              self.__field_unknown1=UINT(value,**{'sizeinbytes': 2, 'default': 0}) 
 537   
 538 -    def __delfield_unknown1(self): del self.__field_unknown1 
 539   
 540      unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 
 541   
 542 -    def __getfield_name(self): 
 543          return self.__field_name.getvalue() 
 544   
 545 -    def __setfield_name(self, value): 
 546          if isinstance(value,USTRING): 
 547              self.__field_name=value 
 548          else: 
 549              self.__field_name=USTRING(value,**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
 550   
 551 -    def __delfield_name(self): del self.__field_name 
 552   
 553      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
 554   
 555 -    def __getfield_group(self): 
 556          return self.__field_group.getvalue() 
 557   
 558 -    def __setfield_group(self, value): 
 559          if isinstance(value,UINT): 
 560              self.__field_group=value 
 561          else: 
 562              self.__field_group=UINT(value,**{'sizeinbytes': 2}) 
 563   
 564 -    def __delfield_group(self): del self.__field_group 
 565   
 566      group=property(__getfield_group, __setfield_group, __delfield_group, None) 
 567   
 568 -    def __getfield_unknown2(self): 
 569          try: self.__field_unknown2 
 570          except: 
 571              self.__field_unknown2=UINT(**{'sizeinbytes': 2, 'default': 0x10}) 
 572          return self.__field_unknown2.getvalue() 
 573   
 574 -    def __setfield_unknown2(self, value): 
 575          if isinstance(value,UINT): 
 576              self.__field_unknown2=value 
 577          else: 
 578              self.__field_unknown2=UINT(value,**{'sizeinbytes': 2, 'default': 0x10}) 
 579   
 580 -    def __delfield_unknown2(self): del self.__field_unknown2 
 581   
 582      unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None) 
 583   
 584 -    def __getfield_secret(self): 
 585          return self.__field_secret.getvalue() 
 586   
 587 -    def __setfield_secret(self, value): 
 588          if isinstance(value,BOOL): 
 589              self.__field_secret=value 
 590          else: 
 591              self.__field_secret=BOOL(value,**{'sizeinbytes': 1}) 
 592   
 593 -    def __delfield_secret(self): del self.__field_secret 
 594   
 595      secret=property(__getfield_secret, __setfield_secret, __delfield_secret, None) 
 596   
 597 -    def __getfield_memo(self): 
 598          return self.__field_memo.getvalue() 
 599   
 600 -    def __setfield_memo(self, value): 
 601          if isinstance(value,USTRING): 
 602              self.__field_memo=value 
 603          else: 
 604              self.__field_memo=USTRING(value,**{'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'sizeinbytes': MEMOLENGTH}) 
 605   
 606 -    def __delfield_memo(self): del self.__field_memo 
 607   
 608      memo=property(__getfield_memo, __setfield_memo, __delfield_memo, None) 
 609   
 610 -    def __getfield_emails(self): 
 611          try: self.__field_emails 
 612          except: 
 613              self.__field_emails=LIST(**{'elementclass': _gen_p_lglg6200_129, 'length': NUMEMAILS}) 
 614          return self.__field_emails.getvalue() 
 615   
 616 -    def __setfield_emails(self, value): 
 617          if isinstance(value,LIST): 
 618              self.__field_emails=value 
 619          else: 
 620              self.__field_emails=LIST(value,**{'elementclass': _gen_p_lglg6200_129, 'length': NUMEMAILS}) 
 621   
 622 -    def __delfield_emails(self): del self.__field_emails 
 623   
 624      emails=property(__getfield_emails, __setfield_emails, __delfield_emails, None) 
 625   
 626 -    def __getfield_url(self): 
 627          return self.__field_url.getvalue() 
 628   
 629 -    def __setfield_url(self, value): 
 630          if isinstance(value,USTRING): 
 631              self.__field_url=value 
 632          else: 
 633              self.__field_url=USTRING(value,**{'sizeinbytes': 73, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
 634   
 635 -    def __delfield_url(self): del self.__field_url 
 636   
 637      url=property(__getfield_url, __setfield_url, __delfield_url, None) 
 638   
 639 -    def __getfield_numberspeeds(self): 
 640          try: self.__field_numberspeeds 
 641          except: 
 642              self.__field_numberspeeds=LIST(**{'elementclass': _gen_p_lglg6200_132, 'length': NUMPHONENUMBERS}) 
 643          return self.__field_numberspeeds.getvalue() 
 644   
 645 -    def __setfield_numberspeeds(self, value): 
 646          if isinstance(value,LIST): 
 647              self.__field_numberspeeds=value 
 648          else: 
 649              self.__field_numberspeeds=LIST(value,**{'elementclass': _gen_p_lglg6200_132, 'length': NUMPHONENUMBERS}) 
 650   
 651 -    def __delfield_numberspeeds(self): del self.__field_numberspeeds 
 652   
 653      numberspeeds=property(__getfield_numberspeeds, __setfield_numberspeeds, __delfield_numberspeeds, None) 
 654   
 655 -    def __getfield_numbertypes(self): 
 656          try: self.__field_numbertypes 
 657          except: 
 658              self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lglg6200_134, 'length': NUMPHONENUMBERS}) 
 659          return self.__field_numbertypes.getvalue() 
 660   
 661 -    def __setfield_numbertypes(self, value): 
 662          if isinstance(value,LIST): 
 663              self.__field_numbertypes=value 
 664          else: 
 665              self.__field_numbertypes=LIST(value,**{'elementclass': _gen_p_lglg6200_134, 'length': NUMPHONENUMBERS}) 
 666   
 667 -    def __delfield_numbertypes(self): del self.__field_numbertypes 
 668   
 669      numbertypes=property(__getfield_numbertypes, __setfield_numbertypes, __delfield_numbertypes, None) 
 670   
 671 -    def __getfield_numbers(self): 
 672          try: self.__field_numbers 
 673          except: 
 674              self.__field_numbers=LIST(**{'elementclass': _gen_p_lglg6200_136, 'length': NUMPHONENUMBERS}) 
 675          return self.__field_numbers.getvalue() 
 676   
 677 -    def __setfield_numbers(self, value): 
 678          if isinstance(value,LIST): 
 679              self.__field_numbers=value 
 680          else: 
 681              self.__field_numbers=LIST(value,**{'elementclass': _gen_p_lglg6200_136, 'length': NUMPHONENUMBERS}) 
 682   
 683 -    def __delfield_numbers(self): del self.__field_numbers 
 684   
 685      numbers=property(__getfield_numbers, __setfield_numbers, __delfield_numbers, None) 
 686   
 687 -    def __getfield_EndOfRecord(self): 
 688          try: self.__field_EndOfRecord 
 689          except: 
 690              self.__field_EndOfRecord=UINT(**{'sizeinbytes': 2, 'constant': 0x0278}) 
 691          return self.__field_EndOfRecord.getvalue() 
 692   
 693 -    def __setfield_EndOfRecord(self, value): 
 694          if isinstance(value,UINT): 
 695              self.__field_EndOfRecord=value 
 696          else: 
 697              self.__field_EndOfRecord=UINT(value,**{'sizeinbytes': 2, 'constant': 0x0278}) 
 698   
 699 -    def __delfield_EndOfRecord(self): del self.__field_EndOfRecord 
 700   
 701      EndOfRecord=property(__getfield_EndOfRecord, __setfield_EndOfRecord, __delfield_EndOfRecord, None) 
 702   
 703 -    def __getfield_ringtone(self): 
 704          try: self.__field_ringtone 
 705          except: 
 706              self.__field_ringtone=UINT(**{'default': 0x600}) 
 707          return self.__field_ringtone.getvalue() 
 708   
 709 -    def __setfield_ringtone(self, value): 
 710          if isinstance(value,UINT): 
 711              self.__field_ringtone=value 
 712          else: 
 713              self.__field_ringtone=UINT(value,**{'default': 0x600}) 
 714   
 715 -    def __delfield_ringtone(self): del self.__field_ringtone 
 716   
 717      ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 
 718   
 719 -    def __getfield_wallpaper(self): 
 720          try: self.__field_wallpaper 
 721          except: 
 722              self.__field_wallpaper=UINT(**{'default': 0x100}) 
 723          return self.__field_wallpaper.getvalue() 
 724   
 725 -    def __setfield_wallpaper(self, value): 
 726          if isinstance(value,UINT): 
 727              self.__field_wallpaper=value 
 728          else: 
 729              self.__field_wallpaper=UINT(value,**{'default': 0x100}) 
 730   
 731 -    def __delfield_wallpaper(self): del self.__field_wallpaper 
 732   
 733      wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None) 
 734   
 735 -    def iscontainer(self): 
 736          return True 
 737   
 738 -    def containerelements(self): 
 739          yield ('serial1', self.__field_serial1, None) 
 740          yield ('entrysize', self.__field_entrysize, None) 
 741          yield ('entrynumber', self.__field_entrynumber, None) 
 742          yield ('unknown1', self.__field_unknown1, None) 
 743          yield ('name', self.__field_name, None) 
 744          yield ('group', self.__field_group, None) 
 745          yield ('unknown2', self.__field_unknown2, None) 
 746          yield ('secret', self.__field_secret, None) 
 747          yield ('memo', self.__field_memo, None) 
 748          yield ('emails', self.__field_emails, None) 
 749          yield ('url', self.__field_url, None) 
 750          yield ('numberspeeds', self.__field_numberspeeds, None) 
 751          yield ('numbertypes', self.__field_numbertypes, None) 
 752          yield ('numbers', self.__field_numbers, None) 
 753          yield ('EndOfRecord', self.__field_EndOfRecord, None) 
 754          yield ('ringtone', self.__field_ringtone, None) 
 755          yield ('wallpaper', self.__field_wallpaper, None) 
 756   
 757   
 758   
 759   
 760 -class _gen_p_lglg6200_129(BaseProtogenClass): 
 761      'Anonymous inner class' 
 762      __fields=['email'] 
 763   
 764 -    def __init__(self, *args, **kwargs): 
 765          dict={} 
 766          # What was supplied to this function 
 767          dict.update(kwargs) 
 768          # Parent constructor 
 769          super(_gen_p_lglg6200_129,self).__init__(**dict) 
 770          if self.__class__ is _gen_p_lglg6200_129: 
 771              self._update(args,dict) 
 772   
 773   
 774 -    def getfields(self): 
 775          return self.__fields 
 776   
 777   
 778 -    def _update(self, args, kwargs): 
 779          super(_gen_p_lglg6200_129,self)._update(args,kwargs) 
 780          keys=kwargs.keys() 
 781          for key in keys: 
 782              if key in self.__fields: 
 783                  setattr(self, key, kwargs[key]) 
 784                  del kwargs[key] 
 785          # Were any unrecognized kwargs passed in? 
 786          if __debug__: 
 787              self._complainaboutunusedargs(_gen_p_lglg6200_129,kwargs) 
 788          if len(args): 
 789              dict2={'sizeinbytes': 73, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False} 
 790              dict2.update(kwargs) 
 791              kwargs=dict2 
 792              self.__field_email=USTRING(*args,**dict2) 
 793          # Make all P fields that haven't already been constructed 
 794   
 795   
 796 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 797          'Writes this packet to the supplied buffer' 
 798          self._bufferstartoffset=buf.getcurrentoffset() 
 799          self.__field_email.writetobuffer(buf) 
 800          self._bufferendoffset=buf.getcurrentoffset() 
 801          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 802   
 803   
 804 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 805          'Reads this packet from the supplied buffer' 
 806          self._bufferstartoffset=buf.getcurrentoffset() 
 807          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 808          self.__field_email=USTRING(**{'sizeinbytes': 73, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
 809          self.__field_email.readfrombuffer(buf) 
 810          self._bufferendoffset=buf.getcurrentoffset() 
 811   
 812   
 813 -    def __getfield_email(self): 
 814          return self.__field_email.getvalue() 
 815   
 816 -    def __setfield_email(self, value): 
 817          if isinstance(value,USTRING): 
 818              self.__field_email=value 
 819          else: 
 820              self.__field_email=USTRING(value,**{'sizeinbytes': 73, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
 821   
 822 -    def __delfield_email(self): del self.__field_email 
 823   
 824      email=property(__getfield_email, __setfield_email, __delfield_email, None) 
 825   
 826 -    def iscontainer(self): 
 827          return True 
 828   
 829 -    def containerelements(self): 
 830          yield ('email', self.__field_email, None) 
 831   
 832   
 833   
 834   
 835 -class _gen_p_lglg6200_132(BaseProtogenClass): 
 836      'Anonymous inner class' 
 837      __fields=['numberspeed'] 
 838   
 839 -    def __init__(self, *args, **kwargs): 
 840          dict={} 
 841          # What was supplied to this function 
 842          dict.update(kwargs) 
 843          # Parent constructor 
 844          super(_gen_p_lglg6200_132,self).__init__(**dict) 
 845          if self.__class__ is _gen_p_lglg6200_132: 
 846              self._update(args,dict) 
 847   
 848   
 849 -    def getfields(self): 
 850          return self.__fields 
 851   
 852   
 853 -    def _update(self, args, kwargs): 
 854          super(_gen_p_lglg6200_132,self)._update(args,kwargs) 
 855          keys=kwargs.keys() 
 856          for key in keys: 
 857              if key in self.__fields: 
 858                  setattr(self, key, kwargs[key]) 
 859                  del kwargs[key] 
 860          # Were any unrecognized kwargs passed in? 
 861          if __debug__: 
 862              self._complainaboutunusedargs(_gen_p_lglg6200_132,kwargs) 
 863          if len(args): 
 864              dict2={'sizeinbytes': 1} 
 865              dict2.update(kwargs) 
 866              kwargs=dict2 
 867              self.__field_numberspeed=UINT(*args,**dict2) 
 868          # Make all P fields that haven't already been constructed 
 869   
 870   
 871 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 872          'Writes this packet to the supplied buffer' 
 873          self._bufferstartoffset=buf.getcurrentoffset() 
 874          self.__field_numberspeed.writetobuffer(buf) 
 875          self._bufferendoffset=buf.getcurrentoffset() 
 876          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 877   
 878   
 879 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 880          'Reads this packet from the supplied buffer' 
 881          self._bufferstartoffset=buf.getcurrentoffset() 
 882          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 883          self.__field_numberspeed=UINT(**{'sizeinbytes': 1}) 
 884          self.__field_numberspeed.readfrombuffer(buf) 
 885          self._bufferendoffset=buf.getcurrentoffset() 
 886   
 887   
 888 -    def __getfield_numberspeed(self): 
 889          return self.__field_numberspeed.getvalue() 
 890   
 891 -    def __setfield_numberspeed(self, value): 
 892          if isinstance(value,UINT): 
 893              self.__field_numberspeed=value 
 894          else: 
 895              self.__field_numberspeed=UINT(value,**{'sizeinbytes': 1}) 
 896   
 897 -    def __delfield_numberspeed(self): del self.__field_numberspeed 
 898   
 899      numberspeed=property(__getfield_numberspeed, __setfield_numberspeed, __delfield_numberspeed, None) 
 900   
 901 -    def iscontainer(self): 
 902          return True 
 903   
 904 -    def containerelements(self): 
 905          yield ('numberspeed', self.__field_numberspeed, None) 
 906   
 907   
 908   
 909   
 910 -class _gen_p_lglg6200_134(BaseProtogenClass): 
 911      'Anonymous inner class' 
 912      __fields=['numbertype'] 
 913   
 914 -    def __init__(self, *args, **kwargs): 
 915          dict={} 
 916          # What was supplied to this function 
 917          dict.update(kwargs) 
 918          # Parent constructor 
 919          super(_gen_p_lglg6200_134,self).__init__(**dict) 
 920          if self.__class__ is _gen_p_lglg6200_134: 
 921              self._update(args,dict) 
 922   
 923   
 924 -    def getfields(self): 
 925          return self.__fields 
 926   
 927   
 928 -    def _update(self, args, kwargs): 
 929          super(_gen_p_lglg6200_134,self)._update(args,kwargs) 
 930          keys=kwargs.keys() 
 931          for key in keys: 
 932              if key in self.__fields: 
 933                  setattr(self, key, kwargs[key]) 
 934                  del kwargs[key] 
 935          # Were any unrecognized kwargs passed in? 
 936          if __debug__: 
 937              self._complainaboutunusedargs(_gen_p_lglg6200_134,kwargs) 
 938          if len(args): 
 939              dict2={'sizeinbytes': 1} 
 940              dict2.update(kwargs) 
 941              kwargs=dict2 
 942              self.__field_numbertype=UINT(*args,**dict2) 
 943          # Make all P fields that haven't already been constructed 
 944   
 945   
 946 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 947          'Writes this packet to the supplied buffer' 
 948          self._bufferstartoffset=buf.getcurrentoffset() 
 949          self.__field_numbertype.writetobuffer(buf) 
 950          self._bufferendoffset=buf.getcurrentoffset() 
 951          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 952   
 953   
 954 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 955          'Reads this packet from the supplied buffer' 
 956          self._bufferstartoffset=buf.getcurrentoffset() 
 957          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 958          self.__field_numbertype=UINT(**{'sizeinbytes': 1}) 
 959          self.__field_numbertype.readfrombuffer(buf) 
 960          self._bufferendoffset=buf.getcurrentoffset() 
 961   
 962   
 963 -    def __getfield_numbertype(self): 
 964          return self.__field_numbertype.getvalue() 
 965   
 966 -    def __setfield_numbertype(self, value): 
 967          if isinstance(value,UINT): 
 968              self.__field_numbertype=value 
 969          else: 
 970              self.__field_numbertype=UINT(value,**{'sizeinbytes': 1}) 
 971   
 972 -    def __delfield_numbertype(self): del self.__field_numbertype 
 973   
 974      numbertype=property(__getfield_numbertype, __setfield_numbertype, __delfield_numbertype, None) 
 975   
 976 -    def iscontainer(self): 
 977          return True 
 978   
 979 -    def containerelements(self): 
 980          yield ('numbertype', self.__field_numbertype, None) 
 981   
 982   
 983   
 984   
 985 -class _gen_p_lglg6200_136(BaseProtogenClass): 
 986      'Anonymous inner class' 
 987      __fields=['number'] 
 988   
 989 -    def __init__(self, *args, **kwargs): 
 990          dict={} 
 991          # What was supplied to this function 
 992          dict.update(kwargs) 
 993          # Parent constructor 
 994          super(_gen_p_lglg6200_136,self).__init__(**dict) 
 995          if self.__class__ is _gen_p_lglg6200_136: 
 996              self._update(args,dict) 
 997   
 998   
 999 -    def getfields(self): 
1000          return self.__fields 
1001   
1002   
1003 -    def _update(self, args, kwargs): 
1004          super(_gen_p_lglg6200_136,self)._update(args,kwargs) 
1005          keys=kwargs.keys() 
1006          for key in keys: 
1007              if key in self.__fields: 
1008                  setattr(self, key, kwargs[key]) 
1009                  del kwargs[key] 
1010          # Were any unrecognized kwargs passed in? 
1011          if __debug__: 
1012              self._complainaboutunusedargs(_gen_p_lglg6200_136,kwargs) 
1013          if len(args): 
1014              dict2={'sizeinbytes': 49, 'raiseonunterminatedread': False} 
1015              dict2.update(kwargs) 
1016              kwargs=dict2 
1017              self.__field_number=USTRING(*args,**dict2) 
1018          # Make all P fields that haven't already been constructed 
1019   
1020   
1021 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1022          'Writes this packet to the supplied buffer' 
1023          self._bufferstartoffset=buf.getcurrentoffset() 
1024          self.__field_number.writetobuffer(buf) 
1025          self._bufferendoffset=buf.getcurrentoffset() 
1026          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1027   
1028   
1029 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1030          'Reads this packet from the supplied buffer' 
1031          self._bufferstartoffset=buf.getcurrentoffset() 
1032          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1033          self.__field_number=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 
1034          self.__field_number.readfrombuffer(buf) 
1035          self._bufferendoffset=buf.getcurrentoffset() 
1036   
1037   
1038 -    def __getfield_number(self): 
1039          return self.__field_number.getvalue() 
1040   
1041 -    def __setfield_number(self, value): 
1042          if isinstance(value,USTRING): 
1043              self.__field_number=value 
1044          else: 
1045              self.__field_number=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 
1046   
1047 -    def __delfield_number(self): del self.__field_number 
1048   
1049      number=property(__getfield_number, __setfield_number, __delfield_number, None) 
1050   
1051 -    def iscontainer(self): 
1052          return True 
1053   
1054 -    def containerelements(self): 
1055          yield ('number', self.__field_number, None) 
1056   
1057   
1058   
1059   
1060 -class pbgroup(BaseProtogenClass): 
1061      "A single group" 
1062      __fields=['group_id', 'rectype', 'unknown2', 'unknown3', 'name'] 
1063   
1064 -    def __init__(self, *args, **kwargs): 
1065          dict={} 
1066          # What was supplied to this function 
1067          dict.update(kwargs) 
1068          # Parent constructor 
1069          super(pbgroup,self).__init__(**dict) 
1070          if self.__class__ is pbgroup: 
1071              self._update(args,dict) 
1072   
1073   
1074 -    def getfields(self): 
1075          return self.__fields 
1076   
1077   
1078 -    def _update(self, args, kwargs): 
1079          super(pbgroup,self)._update(args,kwargs) 
1080          keys=kwargs.keys() 
1081          for key in keys: 
1082              if key in self.__fields: 
1083                  setattr(self, key, kwargs[key]) 
1084                  del kwargs[key] 
1085          # Were any unrecognized kwargs passed in? 
1086          if __debug__: 
1087              self._complainaboutunusedargs(pbgroup,kwargs) 
1088          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1089          # Make all P fields that haven't already been constructed 
1090   
1091   
1092 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1093          'Writes this packet to the supplied buffer' 
1094          self._bufferstartoffset=buf.getcurrentoffset() 
1095          self.__field_group_id.writetobuffer(buf) 
1096          self.__field_rectype.writetobuffer(buf) 
1097          try: self.__field_unknown2 
1098          except: 
1099              self.__field_unknown2=UNKNOWN(**{'sizeinbytes': 3}) 
1100          self.__field_unknown2.writetobuffer(buf) 
1101          try: self.__field_unknown3 
1102          except: 
1103              self.__field_unknown3=UNKNOWN(**{'sizeinbytes': 3}) 
1104          self.__field_unknown3.writetobuffer(buf) 
1105          self.__field_name.writetobuffer(buf) 
1106          self._bufferendoffset=buf.getcurrentoffset() 
1107          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1108   
1109   
1110 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1111          'Reads this packet from the supplied buffer' 
1112          self._bufferstartoffset=buf.getcurrentoffset() 
1113          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1114          self.__field_group_id=UINT(**{'sizeinbytes': 1}) 
1115          self.__field_group_id.readfrombuffer(buf) 
1116          self.__field_rectype=UINT(**{'sizeinbytes': 1}) 
1117          self.__field_rectype.readfrombuffer(buf) 
1118          self.__field_unknown2=UNKNOWN(**{'sizeinbytes': 3}) 
1119          self.__field_unknown2.readfrombuffer(buf) 
1120          self.__field_unknown3=UNKNOWN(**{'sizeinbytes': 3}) 
1121          self.__field_unknown3.readfrombuffer(buf) 
1122          self.__field_name=USTRING(**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
1123          self.__field_name.readfrombuffer(buf) 
1124          self._bufferendoffset=buf.getcurrentoffset() 
1125   
1126   
1127 -    def __getfield_group_id(self): 
1128          return self.__field_group_id.getvalue() 
1129   
1130 -    def __setfield_group_id(self, value): 
1131          if isinstance(value,UINT): 
1132              self.__field_group_id=value 
1133          else: 
1134              self.__field_group_id=UINT(value,**{'sizeinbytes': 1}) 
1135   
1136 -    def __delfield_group_id(self): del self.__field_group_id 
1137   
1138      group_id=property(__getfield_group_id, __setfield_group_id, __delfield_group_id, None) 
1139   
1140 -    def __getfield_rectype(self): 
1141          return self.__field_rectype.getvalue() 
1142   
1143 -    def __setfield_rectype(self, value): 
1144          if isinstance(value,UINT): 
1145              self.__field_rectype=value 
1146          else: 
1147              self.__field_rectype=UINT(value,**{'sizeinbytes': 1}) 
1148   
1149 -    def __delfield_rectype(self): del self.__field_rectype 
1150   
1151      rectype=property(__getfield_rectype, __setfield_rectype, __delfield_rectype, None) 
1152   
1153 -    def __getfield_unknown2(self): 
1154          try: self.__field_unknown2 
1155          except: 
1156              self.__field_unknown2=UNKNOWN(**{'sizeinbytes': 3}) 
1157          return self.__field_unknown2.getvalue() 
1158   
1159 -    def __setfield_unknown2(self, value): 
1160          if isinstance(value,UNKNOWN): 
1161              self.__field_unknown2=value 
1162          else: 
1163              self.__field_unknown2=UNKNOWN(value,**{'sizeinbytes': 3}) 
1164   
1165 -    def __delfield_unknown2(self): del self.__field_unknown2 
1166   
1167      unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None) 
1168   
1169 -    def __getfield_unknown3(self): 
1170          try: self.__field_unknown3 
1171          except: 
1172              self.__field_unknown3=UNKNOWN(**{'sizeinbytes': 3}) 
1173          return self.__field_unknown3.getvalue() 
1174   
1175 -    def __setfield_unknown3(self, value): 
1176          if isinstance(value,UNKNOWN): 
1177              self.__field_unknown3=value 
1178          else: 
1179              self.__field_unknown3=UNKNOWN(value,**{'sizeinbytes': 3}) 
1180   
1181 -    def __delfield_unknown3(self): del self.__field_unknown3 
1182   
1183      unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None) 
1184   
1185 -    def __getfield_name(self): 
1186          return self.__field_name.getvalue() 
1187   
1188 -    def __setfield_name(self, value): 
1189          if isinstance(value,USTRING): 
1190              self.__field_name=value 
1191          else: 
1192              self.__field_name=USTRING(value,**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
1193   
1194 -    def __delfield_name(self): del self.__field_name 
1195   
1196      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
1197   
1198 -    def iscontainer(self): 
1199          return True 
1200   
1201 -    def containerelements(self): 
1202          yield ('group_id', self.__field_group_id, None) 
1203          yield ('rectype', self.__field_rectype, None) 
1204          yield ('unknown2', self.__field_unknown2, None) 
1205          yield ('unknown3', self.__field_unknown3, None) 
1206          yield ('name', self.__field_name, None) 
1207   
1208   
1209   
1210   
1211 -class pbgroups(BaseProtogenClass): 
1212      "Phonebook groups" 
1213      __fields=['groups'] 
1214   
1215 -    def __init__(self, *args, **kwargs): 
1216          dict={} 
1217          # What was supplied to this function 
1218          dict.update(kwargs) 
1219          # Parent constructor 
1220          super(pbgroups,self).__init__(**dict) 
1221          if self.__class__ is pbgroups: 
1222              self._update(args,dict) 
1223   
1224   
1225 -    def getfields(self): 
1226          return self.__fields 
1227   
1228   
1229 -    def _update(self, args, kwargs): 
1230          super(pbgroups,self)._update(args,kwargs) 
1231          keys=kwargs.keys() 
1232          for key in keys: 
1233              if key in self.__fields: 
1234                  setattr(self, key, kwargs[key]) 
1235                  del kwargs[key] 
1236          # Were any unrecognized kwargs passed in? 
1237          if __debug__: 
1238              self._complainaboutunusedargs(pbgroups,kwargs) 
1239          if len(args): 
1240              dict2={'elementclass': pbgroup} 
1241              dict2.update(kwargs) 
1242              kwargs=dict2 
1243              self.__field_groups=LIST(*args,**dict2) 
1244          # Make all P fields that haven't already been constructed 
1245   
1246   
1247 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1248          'Writes this packet to the supplied buffer' 
1249          self._bufferstartoffset=buf.getcurrentoffset() 
1250          try: self.__field_groups 
1251          except: 
1252              self.__field_groups=LIST(**{'elementclass': pbgroup}) 
1253          self.__field_groups.writetobuffer(buf) 
1254          self._bufferendoffset=buf.getcurrentoffset() 
1255          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1256   
1257   
1258 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1259          'Reads this packet from the supplied buffer' 
1260          self._bufferstartoffset=buf.getcurrentoffset() 
1261          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1262          self.__field_groups=LIST(**{'elementclass': pbgroup}) 
1263          self.__field_groups.readfrombuffer(buf) 
1264          self._bufferendoffset=buf.getcurrentoffset() 
1265   
1266   
1267 -    def __getfield_groups(self): 
1268          try: self.__field_groups 
1269          except: 
1270              self.__field_groups=LIST(**{'elementclass': pbgroup}) 
1271          return self.__field_groups.getvalue() 
1272   
1273 -    def __setfield_groups(self, value): 
1274          if isinstance(value,LIST): 
1275              self.__field_groups=value 
1276          else: 
1277              self.__field_groups=LIST(value,**{'elementclass': pbgroup}) 
1278   
1279 -    def __delfield_groups(self): del self.__field_groups 
1280   
1281      groups=property(__getfield_groups, __setfield_groups, __delfield_groups, None) 
1282   
1283 -    def iscontainer(self): 
1284          return True 
1285   
1286 -    def containerelements(self): 
1287          yield ('groups', self.__field_groups, None) 
1288   
1289   
1290   
1291   
1292 -class pb_contact_media_entry(BaseProtogenClass): 
1293      """Reads the wallpaper/ringer info for each  
1294      contact on the phone""" 
1295      __fields=['index', 'dont_care1', 'ringer', 'name', 'dont_care2', 'wallpaper', 'dont_care3'] 
1296   
1297 -    def __init__(self, *args, **kwargs): 
1298          dict={} 
1299          # What was supplied to this function 
1300          dict.update(kwargs) 
1301          # Parent constructor 
1302          super(pb_contact_media_entry,self).__init__(**dict) 
1303          if self.__class__ is pb_contact_media_entry: 
1304              self._update(args,dict) 
1305   
1306   
1307 -    def getfields(self): 
1308          return self.__fields 
1309   
1310   
1311 -    def _update(self, args, kwargs): 
1312          super(pb_contact_media_entry,self)._update(args,kwargs) 
1313          keys=kwargs.keys() 
1314          for key in keys: 
1315              if key in self.__fields: 
1316                  setattr(self, key, kwargs[key]) 
1317                  del kwargs[key] 
1318          # Were any unrecognized kwargs passed in? 
1319          if __debug__: 
1320              self._complainaboutunusedargs(pb_contact_media_entry,kwargs) 
1321          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1322          # Make all P fields that haven't already been constructed 
1323   
1324   
1325 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1326          'Writes this packet to the supplied buffer' 
1327          self._bufferstartoffset=buf.getcurrentoffset() 
1328          self.__field_index.writetobuffer(buf) 
1329          self.__field_dont_care1.writetobuffer(buf) 
1330          self.__field_ringer.writetobuffer(buf) 
1331          self.__field_name.writetobuffer(buf) 
1332          self.__field_dont_care2.writetobuffer(buf) 
1333          self.__field_wallpaper.writetobuffer(buf) 
1334          self.__field_dont_care3.writetobuffer(buf) 
1335          self._bufferendoffset=buf.getcurrentoffset() 
1336          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1337   
1338   
1339 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1340          'Reads this packet from the supplied buffer' 
1341          self._bufferstartoffset=buf.getcurrentoffset() 
1342          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1343          self.__field_index=UINT(**{'sizeinbytes': 2}) 
1344          self.__field_index.readfrombuffer(buf) 
1345          self.__field_dont_care1=DATA(**{'sizeinbytes': 18}) 
1346          self.__field_dont_care1.readfrombuffer(buf) 
1347          self.__field_ringer=UINT(**{'sizeinbytes': 2}) 
1348          self.__field_ringer.readfrombuffer(buf) 
1349          self.__field_name=USTRING(**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING}) 
1350          self.__field_name.readfrombuffer(buf) 
1351          self.__field_dont_care2=DATA(**{'sizeinbytes': 182}) 
1352          self.__field_dont_care2.readfrombuffer(buf) 
1353          self.__field_wallpaper=UINT(**{'sizeinbytes': 2}) 
1354          self.__field_wallpaper.readfrombuffer(buf) 
1355          self.__field_dont_care3=DATA(**{'sizeinbytes': 4}) 
1356          self.__field_dont_care3.readfrombuffer(buf) 
1357          self._bufferendoffset=buf.getcurrentoffset() 
1358   
1359   
1360 -    def __getfield_index(self): 
1361          return self.__field_index.getvalue() 
1362   
1363 -    def __setfield_index(self, value): 
1364          if isinstance(value,UINT): 
1365              self.__field_index=value 
1366          else: 
1367              self.__field_index=UINT(value,**{'sizeinbytes': 2}) 
1368   
1369 -    def __delfield_index(self): del self.__field_index 
1370   
1371      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
1372   
1373 -    def __getfield_dont_care1(self): 
1374          return self.__field_dont_care1.getvalue() 
1375   
1376 -    def __setfield_dont_care1(self, value): 
1377          if isinstance(value,DATA): 
1378              self.__field_dont_care1=value 
1379          else: 
1380              self.__field_dont_care1=DATA(value,**{'sizeinbytes': 18}) 
1381   
1382 -    def __delfield_dont_care1(self): del self.__field_dont_care1 
1383   
1384      dont_care1=property(__getfield_dont_care1, __setfield_dont_care1, __delfield_dont_care1, None) 
1385   
1386 -    def __getfield_ringer(self): 
1387          return self.__field_ringer.getvalue() 
1388   
1389 -    def __setfield_ringer(self, value): 
1390          if isinstance(value,UINT): 
1391              self.__field_ringer=value 
1392          else: 
1393              self.__field_ringer=UINT(value,**{'sizeinbytes': 2}) 
1394   
1395 -    def __delfield_ringer(self): del self.__field_ringer 
1396   
1397      ringer=property(__getfield_ringer, __setfield_ringer, __delfield_ringer, None) 
1398   
1399 -    def __getfield_name(self): 
1400          return self.__field_name.getvalue() 
1401   
1402 -    def __setfield_name(self, value): 
1403          if isinstance(value,USTRING): 
1404              self.__field_name=value 
1405          else: 
1406              self.__field_name=USTRING(value,**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING}) 
1407   
1408 -    def __delfield_name(self): del self.__field_name 
1409   
1410      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
1411   
1412 -    def __getfield_dont_care2(self): 
1413          return self.__field_dont_care2.getvalue() 
1414   
1415 -    def __setfield_dont_care2(self, value): 
1416          if isinstance(value,DATA): 
1417              self.__field_dont_care2=value 
1418          else: 
1419              self.__field_dont_care2=DATA(value,**{'sizeinbytes': 182}) 
1420   
1421 -    def __delfield_dont_care2(self): del self.__field_dont_care2 
1422   
1423      dont_care2=property(__getfield_dont_care2, __setfield_dont_care2, __delfield_dont_care2, None) 
1424   
1425 -    def __getfield_wallpaper(self): 
1426          return self.__field_wallpaper.getvalue() 
1427   
1428 -    def __setfield_wallpaper(self, value): 
1429          if isinstance(value,UINT): 
1430              self.__field_wallpaper=value 
1431          else: 
1432              self.__field_wallpaper=UINT(value,**{'sizeinbytes': 2}) 
1433   
1434 -    def __delfield_wallpaper(self): del self.__field_wallpaper 
1435   
1436      wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None) 
1437   
1438 -    def __getfield_dont_care3(self): 
1439          return self.__field_dont_care3.getvalue() 
1440   
1441 -    def __setfield_dont_care3(self, value): 
1442          if isinstance(value,DATA): 
1443              self.__field_dont_care3=value 
1444          else: 
1445              self.__field_dont_care3=DATA(value,**{'sizeinbytes': 4}) 
1446   
1447 -    def __delfield_dont_care3(self): del self.__field_dont_care3 
1448   
1449      dont_care3=property(__getfield_dont_care3, __setfield_dont_care3, __delfield_dont_care3, None) 
1450   
1451 -    def iscontainer(self): 
1452          return True 
1453   
1454 -    def containerelements(self): 
1455          yield ('index', self.__field_index, None) 
1456          yield ('dont_care1', self.__field_dont_care1, None) 
1457          yield ('ringer', self.__field_ringer, None) 
1458          yield ('name', self.__field_name, None) 
1459          yield ('dont_care2', self.__field_dont_care2, None) 
1460          yield ('wallpaper', self.__field_wallpaper, None) 
1461          yield ('dont_care3', self.__field_dont_care3, None) 
1462   
1463   
1464   
1465   
1466 -class pb_contact_media_file(BaseProtogenClass): 
1467      __fields=['contacts'] 
1468   
1469 -    def __init__(self, *args, **kwargs): 
1470          dict={} 
1471          # What was supplied to this function 
1472          dict.update(kwargs) 
1473          # Parent constructor 
1474          super(pb_contact_media_file,self).__init__(**dict) 
1475          if self.__class__ is pb_contact_media_file: 
1476              self._update(args,dict) 
1477   
1478   
1479 -    def getfields(self): 
1480          return self.__fields 
1481   
1482   
1483 -    def _update(self, args, kwargs): 
1484          super(pb_contact_media_file,self)._update(args,kwargs) 
1485          keys=kwargs.keys() 
1486          for key in keys: 
1487              if key in self.__fields: 
1488                  setattr(self, key, kwargs[key]) 
1489                  del kwargs[key] 
1490          # Were any unrecognized kwargs passed in? 
1491          if __debug__: 
1492              self._complainaboutunusedargs(pb_contact_media_file,kwargs) 
1493          if len(args): 
1494              dict2={'elementclass': pb_contact_media_entry} 
1495              dict2.update(kwargs) 
1496              kwargs=dict2 
1497              self.__field_contacts=LIST(*args,**dict2) 
1498          # Make all P fields that haven't already been constructed 
1499   
1500   
1501 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1502          'Writes this packet to the supplied buffer' 
1503          self._bufferstartoffset=buf.getcurrentoffset() 
1504          try: self.__field_contacts 
1505          except: 
1506              self.__field_contacts=LIST(**{'elementclass': pb_contact_media_entry}) 
1507          self.__field_contacts.writetobuffer(buf) 
1508          self._bufferendoffset=buf.getcurrentoffset() 
1509          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1510   
1511   
1512 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1513          'Reads this packet from the supplied buffer' 
1514          self._bufferstartoffset=buf.getcurrentoffset() 
1515          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1516          self.__field_contacts=LIST(**{'elementclass': pb_contact_media_entry}) 
1517          self.__field_contacts.readfrombuffer(buf) 
1518          self._bufferendoffset=buf.getcurrentoffset() 
1519   
1520   
1521 -    def __getfield_contacts(self): 
1522          try: self.__field_contacts 
1523          except: 
1524              self.__field_contacts=LIST(**{'elementclass': pb_contact_media_entry}) 
1525          return self.__field_contacts.getvalue() 
1526   
1527 -    def __setfield_contacts(self, value): 
1528          if isinstance(value,LIST): 
1529              self.__field_contacts=value 
1530          else: 
1531              self.__field_contacts=LIST(value,**{'elementclass': pb_contact_media_entry}) 
1532   
1533 -    def __delfield_contacts(self): del self.__field_contacts 
1534   
1535      contacts=property(__getfield_contacts, __setfield_contacts, __delfield_contacts, None) 
1536   
1537 -    def iscontainer(self): 
1538          return True 
1539   
1540 -    def containerelements(self): 
1541          yield ('contacts', self.__field_contacts, None) 
1542   
1543   
1544   
1545   
1546 -class indexentry(BaseProtogenClass): 
1547      __fields=['index', 'const', 'name'] 
1548   
1549 -    def __init__(self, *args, **kwargs): 
1550          dict={} 
1551          # What was supplied to this function 
1552          dict.update(kwargs) 
1553          # Parent constructor 
1554          super(indexentry,self).__init__(**dict) 
1555          if self.__class__ is indexentry: 
1556              self._update(args,dict) 
1557   
1558   
1559 -    def getfields(self): 
1560          return self.__fields 
1561   
1562   
1563 -    def _update(self, args, kwargs): 
1564          super(indexentry,self)._update(args,kwargs) 
1565          keys=kwargs.keys() 
1566          for key in keys: 
1567              if key in self.__fields: 
1568                  setattr(self, key, kwargs[key]) 
1569                  del kwargs[key] 
1570          # Were any unrecognized kwargs passed in? 
1571          if __debug__: 
1572              self._complainaboutunusedargs(indexentry,kwargs) 
1573          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1574          # Make all P fields that haven't already been constructed 
1575   
1576   
1577 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1578          'Writes this packet to the supplied buffer' 
1579          self._bufferstartoffset=buf.getcurrentoffset() 
1580          self.__field_index.writetobuffer(buf) 
1581          self.__field_const.writetobuffer(buf) 
1582          try: self.__field_name 
1583          except: 
1584              self.__field_name=USTRING(**{'sizeinbytes': 80, 'default': ""}) 
1585          self.__field_name.writetobuffer(buf) 
1586          self._bufferendoffset=buf.getcurrentoffset() 
1587          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1588   
1589   
1590 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1591          'Reads this packet from the supplied buffer' 
1592          self._bufferstartoffset=buf.getcurrentoffset() 
1593          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1594          self.__field_index=UINT(**{'sizeinbytes': 1}) 
1595          self.__field_index.readfrombuffer(buf) 
1596          self.__field_const=UINT(**{'sizeinbytes': 1}) 
1597          self.__field_const.readfrombuffer(buf) 
1598          self.__field_name=USTRING(**{'sizeinbytes': 80, 'default': ""}) 
1599          self.__field_name.readfrombuffer(buf) 
1600          self._bufferendoffset=buf.getcurrentoffset() 
1601   
1602   
1603 -    def __getfield_index(self): 
1604          return self.__field_index.getvalue() 
1605   
1606 -    def __setfield_index(self, value): 
1607          if isinstance(value,UINT): 
1608              self.__field_index=value 
1609          else: 
1610              self.__field_index=UINT(value,**{'sizeinbytes': 1}) 
1611   
1612 -    def __delfield_index(self): del self.__field_index 
1613   
1614      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
1615   
1616 -    def __getfield_const(self): 
1617          return self.__field_const.getvalue() 
1618   
1619 -    def __setfield_const(self, value): 
1620          if isinstance(value,UINT): 
1621              self.__field_const=value 
1622          else: 
1623              self.__field_const=UINT(value,**{'sizeinbytes': 1}) 
1624   
1625 -    def __delfield_const(self): del self.__field_const 
1626   
1627      const=property(__getfield_const, __setfield_const, __delfield_const, None) 
1628   
1629 -    def __getfield_name(self): 
1630          try: self.__field_name 
1631          except: 
1632              self.__field_name=USTRING(**{'sizeinbytes': 80, 'default': ""}) 
1633          return self.__field_name.getvalue() 
1634   
1635 -    def __setfield_name(self, value): 
1636          if isinstance(value,USTRING): 
1637              self.__field_name=value 
1638          else: 
1639              self.__field_name=USTRING(value,**{'sizeinbytes': 80, 'default': ""}) 
1640   
1641 -    def __delfield_name(self): del self.__field_name 
1642   
1643      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
1644   
1645 -    def iscontainer(self): 
1646          return True 
1647   
1648 -    def containerelements(self): 
1649          yield ('index', self.__field_index, None) 
1650          yield ('const', self.__field_const, None) 
1651          yield ('name', self.__field_name, None) 
1652   
1653   
1654   
1655   
1656 -class indexfile(BaseProtogenClass): 
1657      "Used for tracking wallpaper and ringtones" 
1658      __fields=['numactiveitems', 'items'] 
1659   
1660 -    def __init__(self, *args, **kwargs): 
1661          dict={} 
1662          # What was supplied to this function 
1663          dict.update(kwargs) 
1664          # Parent constructor 
1665          super(indexfile,self).__init__(**dict) 
1666          if self.__class__ is indexfile: 
1667              self._update(args,dict) 
1668   
1669   
1670 -    def getfields(self): 
1671          return self.__fields 
1672   
1673   
1674 -    def _update(self, args, kwargs): 
1675          super(indexfile,self)._update(args,kwargs) 
1676          keys=kwargs.keys() 
1677          for key in keys: 
1678              if key in self.__fields: 
1679                  setattr(self, key, kwargs[key]) 
1680                  del kwargs[key] 
1681          # Were any unrecognized kwargs passed in? 
1682          if __debug__: 
1683              self._complainaboutunusedargs(indexfile,kwargs) 
1684          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1685          # Make all P fields that haven't already been constructed 
1686   
1687   
1688 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1689          'Writes this packet to the supplied buffer' 
1690          self._bufferstartoffset=buf.getcurrentoffset() 
1691          self.__field_numactiveitems.writetobuffer(buf) 
1692          try: self.__field_items 
1693          except: 
1694              self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True}) 
1695          self.__field_items.writetobuffer(buf) 
1696          self._bufferendoffset=buf.getcurrentoffset() 
1697          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1698   
1699   
1700 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1701          'Reads this packet from the supplied buffer' 
1702          self._bufferstartoffset=buf.getcurrentoffset() 
1703          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1704          self.__field_numactiveitems=UINT(**{'sizeinbytes': 2}) 
1705          self.__field_numactiveitems.readfrombuffer(buf) 
1706          self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True}) 
1707          self.__field_items.readfrombuffer(buf) 
1708          self._bufferendoffset=buf.getcurrentoffset() 
1709   
1710   
1711 -    def __getfield_numactiveitems(self): 
1712          return self.__field_numactiveitems.getvalue() 
1713   
1714 -    def __setfield_numactiveitems(self, value): 
1715          if isinstance(value,UINT): 
1716              self.__field_numactiveitems=value 
1717          else: 
1718              self.__field_numactiveitems=UINT(value,**{'sizeinbytes': 2}) 
1719   
1720 -    def __delfield_numactiveitems(self): del self.__field_numactiveitems 
1721   
1722      numactiveitems=property(__getfield_numactiveitems, __setfield_numactiveitems, __delfield_numactiveitems, None) 
1723   
1724 -    def __getfield_items(self): 
1725          try: self.__field_items 
1726          except: 
1727              self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True}) 
1728          return self.__field_items.getvalue() 
1729   
1730 -    def __setfield_items(self, value): 
1731          if isinstance(value,LIST): 
1732              self.__field_items=value 
1733          else: 
1734              self.__field_items=LIST(value,**{'elementclass': indexentry, 'createdefault': True}) 
1735   
1736 -    def __delfield_items(self): del self.__field_items 
1737   
1738      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
1739   
1740 -    def iscontainer(self): 
1741          return True 
1742   
1743 -    def containerelements(self): 
1744          yield ('numactiveitems', self.__field_numactiveitems, None) 
1745          yield ('items', self.__field_items, None) 
1746   
1747   
1748   
1749   
1750 -class content_entry(BaseProtogenClass): 
1751      __fields=['type', 'index1', 'name1', 'unknown1', 'unknown2', 'mime_type', 'content_type', 'url', 'unknown_int1', 'unknown3', 'unknown_int2', 'unknown4', 'unknown5', 'size', 'location_maybe', 'index2', 'name2', 'unknown6'] 
1752   
1753 -    def __init__(self, *args, **kwargs): 
1754          dict={} 
1755          # What was supplied to this function 
1756          dict.update(kwargs) 
1757          # Parent constructor 
1758          super(content_entry,self).__init__(**dict) 
1759          if self.__class__ is content_entry: 
1760              self._update(args,dict) 
1761   
1762   
1763 -    def getfields(self): 
1764          return self.__fields 
1765   
1766   
1767 -    def _update(self, args, kwargs): 
1768          super(content_entry,self)._update(args,kwargs) 
1769          keys=kwargs.keys() 
1770          for key in keys: 
1771              if key in self.__fields: 
1772                  setattr(self, key, kwargs[key]) 
1773                  del kwargs[key] 
1774          # Were any unrecognized kwargs passed in? 
1775          if __debug__: 
1776              self._complainaboutunusedargs(content_entry,kwargs) 
1777          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1778          # Make all P fields that haven't already been constructed 
1779   
1780   
1781 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1782          'Writes this packet to the supplied buffer' 
1783          self._bufferstartoffset=buf.getcurrentoffset() 
1784          self.__field_type.writetobuffer(buf) 
1785          if self.type=='!C': 
1786              self.__field_index1.writetobuffer(buf) 
1787              self.__field_name1.writetobuffer(buf) 
1788              try: self.__field_unknown1 
1789              except: 
1790                  self.__field_unknown1=USTRING(**{'terminator': 0xA, 'default': '-1'}) 
1791              self.__field_unknown1.writetobuffer(buf) 
1792              try: self.__field_unknown2 
1793              except: 
1794                  self.__field_unknown2=UINT(**{'sizeinbytes': 8, 'default' :0}) 
1795              self.__field_unknown2.writetobuffer(buf) 
1796              self.__field_mime_type.writetobuffer(buf) 
1797              self.__field_content_type.writetobuffer(buf) 
1798              try: self.__field_url 
1799              except: 
1800                  self.__field_url=USTRING(**{'terminator': 0xA, 'default':'bitpim.org'}) 
1801              self.__field_url.writetobuffer(buf) 
1802              try: self.__field_unknown_int1 
1803              except: 
1804                  self.__field_unknown_int1=UINT(**{'sizeinbytes': 2, 'default':0x08AA}) 
1805              self.__field_unknown_int1.writetobuffer(buf) 
1806              try: self.__field_unknown3 
1807              except: 
1808                  self.__field_unknown3=USTRING(**{'terminator': 0xA, 'default':''}) 
1809              self.__field_unknown3.writetobuffer(buf) 
1810              try: self.__field_unknown_int2 
1811              except: 
1812                  self.__field_unknown_int2=UINT(**{'sizeinbytes': 2, 'default':0x08AA}) 
1813              self.__field_unknown_int2.writetobuffer(buf) 
1814              try: self.__field_unknown4 
1815              except: 
1816                  self.__field_unknown4=USTRING(**{'terminator': 0xA, 'default':''}) 
1817              self.__field_unknown4.writetobuffer(buf) 
1818              try: self.__field_unknown5 
1819              except: 
1820                  self.__field_unknown5=USTRING(**{'terminator': 0xA, 'default':'0'}) 
1821              self.__field_unknown5.writetobuffer(buf) 
1822              self.__field_size.writetobuffer(buf) 
1823          if self.type=='!E': 
1824              try: self.__field_location_maybe 
1825              except: 
1826                  self.__field_location_maybe=USTRING(**{'terminator': 0xA, 'default':'ams:'}) 
1827              self.__field_location_maybe.writetobuffer(buf) 
1828              self.__field_index2.writetobuffer(buf) 
1829              self.__field_name2.writetobuffer(buf) 
1830              try: self.__field_unknown6 
1831              except: 
1832                  self.__field_unknown6=USTRING(**{'terminator': 0xA, 'default':''}) 
1833              self.__field_unknown6.writetobuffer(buf) 
1834          self._bufferendoffset=buf.getcurrentoffset() 
1835          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1836   
1837   
1838 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1839          'Reads this packet from the supplied buffer' 
1840          self._bufferstartoffset=buf.getcurrentoffset() 
1841          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1842          self.__field_type=USTRING(**{'sizeinbytes': 3, 'terminator': 0xA}) 
1843          self.__field_type.readfrombuffer(buf) 
1844          if self.type=='!C': 
1845              self.__field_index1=USTRING(**{'terminator': 0xA}) 
1846              self.__field_index1.readfrombuffer(buf) 
1847              self.__field_name1=USTRING(**{'terminator': 0xA}) 
1848              self.__field_name1.readfrombuffer(buf) 
1849              self.__field_unknown1=USTRING(**{'terminator': 0xA, 'default': '-1'}) 
1850              self.__field_unknown1.readfrombuffer(buf) 
1851              self.__field_unknown2=UINT(**{'sizeinbytes': 8, 'default' :0}) 
1852              self.__field_unknown2.readfrombuffer(buf) 
1853              self.__field_mime_type=USTRING(**{'terminator': 0xA}) 
1854              self.__field_mime_type.readfrombuffer(buf) 
1855              self.__field_content_type=USTRING(**{'terminator': 0xA}) 
1856              self.__field_content_type.readfrombuffer(buf) 
1857              self.__field_url=USTRING(**{'terminator': 0xA, 'default':'bitpim.org'}) 
1858              self.__field_url.readfrombuffer(buf) 
1859              self.__field_unknown_int1=UINT(**{'sizeinbytes': 2, 'default':0x08AA}) 
1860              self.__field_unknown_int1.readfrombuffer(buf) 
1861              self.__field_unknown3=USTRING(**{'terminator': 0xA, 'default':''}) 
1862              self.__field_unknown3.readfrombuffer(buf) 
1863              self.__field_unknown_int2=UINT(**{'sizeinbytes': 2, 'default':0x08AA}) 
1864              self.__field_unknown_int2.readfrombuffer(buf) 
1865              self.__field_unknown4=USTRING(**{'terminator': 0xA, 'default':''}) 
1866              self.__field_unknown4.readfrombuffer(buf) 
1867              self.__field_unknown5=USTRING(**{'terminator': 0xA, 'default':'0'}) 
1868              self.__field_unknown5.readfrombuffer(buf) 
1869              self.__field_size=USTRING(**{'terminator': 0xA}) 
1870              self.__field_size.readfrombuffer(buf) 
1871          if self.type=='!E': 
1872              self.__field_location_maybe=USTRING(**{'terminator': 0xA, 'default':'ams:'}) 
1873              self.__field_location_maybe.readfrombuffer(buf) 
1874              self.__field_index2=USTRING(**{'terminator': 0xA}) 
1875              self.__field_index2.readfrombuffer(buf) 
1876              self.__field_name2=USTRING(**{'terminator': 0xA}) 
1877              self.__field_name2.readfrombuffer(buf) 
1878              self.__field_unknown6=USTRING(**{'terminator': 0xA, 'default':''}) 
1879              self.__field_unknown6.readfrombuffer(buf) 
1880          self._bufferendoffset=buf.getcurrentoffset() 
1881   
1882   
1883 -    def __getfield_type(self): 
1884          return self.__field_type.getvalue() 
1885   
1886 -    def __setfield_type(self, value): 
1887          if isinstance(value,USTRING): 
1888              self.__field_type=value 
1889          else: 
1890              self.__field_type=USTRING(value,**{'sizeinbytes': 3, 'terminator': 0xA}) 
1891   
1892 -    def __delfield_type(self): del self.__field_type 
1893   
1894      type=property(__getfield_type, __setfield_type, __delfield_type, None) 
1895   
1896 -    def __getfield_index1(self): 
1897          return self.__field_index1.getvalue() 
1898   
1899 -    def __setfield_index1(self, value): 
1900          if isinstance(value,USTRING): 
1901              self.__field_index1=value 
1902          else: 
1903              self.__field_index1=USTRING(value,**{'terminator': 0xA}) 
1904   
1905 -    def __delfield_index1(self): del self.__field_index1 
1906   
1907      index1=property(__getfield_index1, __setfield_index1, __delfield_index1, None) 
1908   
1909 -    def __getfield_name1(self): 
1910          return self.__field_name1.getvalue() 
1911   
1912 -    def __setfield_name1(self, value): 
1913          if isinstance(value,USTRING): 
1914              self.__field_name1=value 
1915          else: 
1916              self.__field_name1=USTRING(value,**{'terminator': 0xA}) 
1917   
1918 -    def __delfield_name1(self): del self.__field_name1 
1919   
1920      name1=property(__getfield_name1, __setfield_name1, __delfield_name1, None) 
1921   
1922 -    def __getfield_unknown1(self): 
1923          try: self.__field_unknown1 
1924          except: 
1925              self.__field_unknown1=USTRING(**{'terminator': 0xA, 'default': '-1'}) 
1926          return self.__field_unknown1.getvalue() 
1927   
1928 -    def __setfield_unknown1(self, value): 
1929          if isinstance(value,USTRING): 
1930              self.__field_unknown1=value 
1931          else: 
1932              self.__field_unknown1=USTRING(value,**{'terminator': 0xA, 'default': '-1'}) 
1933   
1934 -    def __delfield_unknown1(self): del self.__field_unknown1 
1935   
1936      unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 
1937   
1938 -    def __getfield_unknown2(self): 
1939          try: self.__field_unknown2 
1940          except: 
1941              self.__field_unknown2=UINT(**{'sizeinbytes': 8, 'default' :0}) 
1942          return self.__field_unknown2.getvalue() 
1943   
1944 -    def __setfield_unknown2(self, value): 
1945          if isinstance(value,UINT): 
1946              self.__field_unknown2=value 
1947          else: 
1948              self.__field_unknown2=UINT(value,**{'sizeinbytes': 8, 'default' :0}) 
1949   
1950 -    def __delfield_unknown2(self): del self.__field_unknown2 
1951   
1952      unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None) 
1953   
1954 -    def __getfield_mime_type(self): 
1955          return self.__field_mime_type.getvalue() 
1956   
1957 -    def __setfield_mime_type(self, value): 
1958          if isinstance(value,USTRING): 
1959              self.__field_mime_type=value 
1960          else: 
1961              self.__field_mime_type=USTRING(value,**{'terminator': 0xA}) 
1962   
1963 -    def __delfield_mime_type(self): del self.__field_mime_type 
1964   
1965      mime_type=property(__getfield_mime_type, __setfield_mime_type, __delfield_mime_type, None) 
1966   
1967 -    def __getfield_content_type(self): 
1968          return self.__field_content_type.getvalue() 
1969   
1970 -    def __setfield_content_type(self, value): 
1971          if isinstance(value,USTRING): 
1972              self.__field_content_type=value 
1973          else: 
1974              self.__field_content_type=USTRING(value,**{'terminator': 0xA}) 
1975   
1976 -    def __delfield_content_type(self): del self.__field_content_type 
1977   
1978      content_type=property(__getfield_content_type, __setfield_content_type, __delfield_content_type, None) 
1979   
1980 -    def __getfield_url(self): 
1981          try: self.__field_url 
1982          except: 
1983              self.__field_url=USTRING(**{'terminator': 0xA, 'default':'bitpim.org'}) 
1984          return self.__field_url.getvalue() 
1985   
1986 -    def __setfield_url(self, value): 
1987          if isinstance(value,USTRING): 
1988              self.__field_url=value 
1989          else: 
1990              self.__field_url=USTRING(value,**{'terminator': 0xA, 'default':'bitpim.org'}) 
1991   
1992 -    def __delfield_url(self): del self.__field_url 
1993   
1994      url=property(__getfield_url, __setfield_url, __delfield_url, None) 
1995   
1996 -    def __getfield_unknown_int1(self): 
1997          try: self.__field_unknown_int1 
1998          except: 
1999              self.__field_unknown_int1=UINT(**{'sizeinbytes': 2, 'default':0x08AA}) 
2000          return self.__field_unknown_int1.getvalue() 
2001   
2002 -    def __setfield_unknown_int1(self, value): 
2003          if isinstance(value,UINT): 
2004              self.__field_unknown_int1=value 
2005          else: 
2006              self.__field_unknown_int1=UINT(value,**{'sizeinbytes': 2, 'default':0x08AA}) 
2007   
2008 -    def __delfield_unknown_int1(self): del self.__field_unknown_int1 
2009   
2010      unknown_int1=property(__getfield_unknown_int1, __setfield_unknown_int1, __delfield_unknown_int1, None) 
2011   
2012 -    def __getfield_unknown3(self): 
2013          try: self.__field_unknown3 
2014          except: 
2015              self.__field_unknown3=USTRING(**{'terminator': 0xA, 'default':''}) 
2016          return self.__field_unknown3.getvalue() 
2017   
2018 -    def __setfield_unknown3(self, value): 
2019          if isinstance(value,USTRING): 
2020              self.__field_unknown3=value 
2021          else: 
2022              self.__field_unknown3=USTRING(value,**{'terminator': 0xA, 'default':''}) 
2023   
2024 -    def __delfield_unknown3(self): del self.__field_unknown3 
2025   
2026      unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None) 
2027   
2028 -    def __getfield_unknown_int2(self): 
2029          try: self.__field_unknown_int2 
2030          except: 
2031              self.__field_unknown_int2=UINT(**{'sizeinbytes': 2, 'default':0x08AA}) 
2032          return self.__field_unknown_int2.getvalue() 
2033   
2034 -    def __setfield_unknown_int2(self, value): 
2035          if isinstance(value,UINT): 
2036              self.__field_unknown_int2=value 
2037          else: 
2038              self.__field_unknown_int2=UINT(value,**{'sizeinbytes': 2, 'default':0x08AA}) 
2039   
2040 -    def __delfield_unknown_int2(self): del self.__field_unknown_int2 
2041   
2042      unknown_int2=property(__getfield_unknown_int2, __setfield_unknown_int2, __delfield_unknown_int2, None) 
2043   
2044 -    def __getfield_unknown4(self): 
2045          try: self.__field_unknown4 
2046          except: 
2047              self.__field_unknown4=USTRING(**{'terminator': 0xA, 'default':''}) 
2048          return self.__field_unknown4.getvalue() 
2049   
2050 -    def __setfield_unknown4(self, value): 
2051          if isinstance(value,USTRING): 
2052              self.__field_unknown4=value 
2053          else: 
2054              self.__field_unknown4=USTRING(value,**{'terminator': 0xA, 'default':''}) 
2055   
2056 -    def __delfield_unknown4(self): del self.__field_unknown4 
2057   
2058      unknown4=property(__getfield_unknown4, __setfield_unknown4, __delfield_unknown4, None) 
2059   
2060 -    def __getfield_unknown5(self): 
2061          try: self.__field_unknown5 
2062          except: 
2063              self.__field_unknown5=USTRING(**{'terminator': 0xA, 'default':'0'}) 
2064          return self.__field_unknown5.getvalue() 
2065   
2066 -    def __setfield_unknown5(self, value): 
2067          if isinstance(value,USTRING): 
2068              self.__field_unknown5=value 
2069          else: 
2070              self.__field_unknown5=USTRING(value,**{'terminator': 0xA, 'default':'0'}) 
2071   
2072 -    def __delfield_unknown5(self): del self.__field_unknown5 
2073   
2074      unknown5=property(__getfield_unknown5, __setfield_unknown5, __delfield_unknown5, None) 
2075   
2076 -    def __getfield_size(self): 
2077          return self.__field_size.getvalue() 
2078   
2079 -    def __setfield_size(self, value): 
2080          if isinstance(value,USTRING): 
2081              self.__field_size=value 
2082          else: 
2083              self.__field_size=USTRING(value,**{'terminator': 0xA}) 
2084   
2085 -    def __delfield_size(self): del self.__field_size 
2086   
2087      size=property(__getfield_size, __setfield_size, __delfield_size, None) 
2088   
2089 -    def __getfield_location_maybe(self): 
2090          try: self.__field_location_maybe 
2091          except: 
2092              self.__field_location_maybe=USTRING(**{'terminator': 0xA, 'default':'ams:'}) 
2093          return self.__field_location_maybe.getvalue() 
2094   
2095 -    def __setfield_location_maybe(self, value): 
2096          if isinstance(value,USTRING): 
2097              self.__field_location_maybe=value 
2098          else: 
2099              self.__field_location_maybe=USTRING(value,**{'terminator': 0xA, 'default':'ams:'}) 
2100   
2101 -    def __delfield_location_maybe(self): del self.__field_location_maybe 
2102   
2103      location_maybe=property(__getfield_location_maybe, __setfield_location_maybe, __delfield_location_maybe, None) 
2104   
2105 -    def __getfield_index2(self): 
2106          return self.__field_index2.getvalue() 
2107   
2108 -    def __setfield_index2(self, value): 
2109          if isinstance(value,USTRING): 
2110              self.__field_index2=value 
2111          else: 
2112              self.__field_index2=USTRING(value,**{'terminator': 0xA}) 
2113   
2114 -    def __delfield_index2(self): del self.__field_index2 
2115   
2116      index2=property(__getfield_index2, __setfield_index2, __delfield_index2, None) 
2117   
2118 -    def __getfield_name2(self): 
2119          return self.__field_name2.getvalue() 
2120   
2121 -    def __setfield_name2(self, value): 
2122          if isinstance(value,USTRING): 
2123              self.__field_name2=value 
2124          else: 
2125              self.__field_name2=USTRING(value,**{'terminator': 0xA}) 
2126   
2127 -    def __delfield_name2(self): del self.__field_name2 
2128   
2129      name2=property(__getfield_name2, __setfield_name2, __delfield_name2, None) 
2130   
2131 -    def __getfield_unknown6(self): 
2132          try: self.__field_unknown6 
2133          except: 
2134              self.__field_unknown6=USTRING(**{'terminator': 0xA, 'default':''}) 
2135          return self.__field_unknown6.getvalue() 
2136   
2137 -    def __setfield_unknown6(self, value): 
2138          if isinstance(value,USTRING): 
2139              self.__field_unknown6=value 
2140          else: 
2141              self.__field_unknown6=USTRING(value,**{'terminator': 0xA, 'default':''}) 
2142   
2143 -    def __delfield_unknown6(self): del self.__field_unknown6 
2144   
2145      unknown6=property(__getfield_unknown6, __setfield_unknown6, __delfield_unknown6, None) 
2146   
2147 -    def iscontainer(self): 
2148          return True 
2149   
2150 -    def containerelements(self): 
2151          yield ('type', self.__field_type, None) 
2152          if self.type=='!C': 
2153              yield ('index1', self.__field_index1, None) 
2154              yield ('name1', self.__field_name1, None) 
2155              yield ('unknown1', self.__field_unknown1, None) 
2156              yield ('unknown2', self.__field_unknown2, None) 
2157              yield ('mime_type', self.__field_mime_type, None) 
2158              yield ('content_type', self.__field_content_type, None) 
2159              yield ('url', self.__field_url, None) 
2160              yield ('unknown_int1', self.__field_unknown_int1, None) 
2161              yield ('unknown3', self.__field_unknown3, None) 
2162              yield ('unknown_int2', self.__field_unknown_int2, None) 
2163              yield ('unknown4', self.__field_unknown4, None) 
2164              yield ('unknown5', self.__field_unknown5, None) 
2165              yield ('size', self.__field_size, None) 
2166          if self.type=='!E': 
2167              yield ('location_maybe', self.__field_location_maybe, None) 
2168              yield ('index2', self.__field_index2, None) 
2169              yield ('name2', self.__field_name2, None) 
2170              yield ('unknown6', self.__field_unknown6, None) 
2171   
2172   
2173   
2174   
2175 -class content_file(BaseProtogenClass): 
2176      "Used to store all content on the phone, apps, ringers and images (with the exception of the camera)" 
2177      __fields=['items'] 
2178   
2179 -    def __init__(self, *args, **kwargs): 
2180          dict={} 
2181          # What was supplied to this function 
2182          dict.update(kwargs) 
2183          # Parent constructor 
2184          super(content_file,self).__init__(**dict) 
2185          if self.__class__ is content_file: 
2186              self._update(args,dict) 
2187   
2188   
2189 -    def getfields(self): 
2190          return self.__fields 
2191   
2192   
2193 -    def _update(self, args, kwargs): 
2194          super(content_file,self)._update(args,kwargs) 
2195          keys=kwargs.keys() 
2196          for key in keys: 
2197              if key in self.__fields: 
2198                  setattr(self, key, kwargs[key]) 
2199                  del kwargs[key] 
2200          # Were any unrecognized kwargs passed in? 
2201          if __debug__: 
2202              self._complainaboutunusedargs(content_file,kwargs) 
2203          if len(args): 
2204              dict2={'elementclass': content_entry, 'createdefault': True} 
2205              dict2.update(kwargs) 
2206              kwargs=dict2 
2207              self.__field_items=LIST(*args,**dict2) 
2208          # Make all P fields that haven't already been constructed 
2209   
2210   
2211 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2212          'Writes this packet to the supplied buffer' 
2213          self._bufferstartoffset=buf.getcurrentoffset() 
2214          try: self.__field_items 
2215          except: 
2216              self.__field_items=LIST(**{'elementclass': content_entry, 'createdefault': True}) 
2217          self.__field_items.writetobuffer(buf) 
2218          self._bufferendoffset=buf.getcurrentoffset() 
2219          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2220   
2221   
2222 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2223          'Reads this packet from the supplied buffer' 
2224          self._bufferstartoffset=buf.getcurrentoffset() 
2225          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2226          self.__field_items=LIST(**{'elementclass': content_entry, 'createdefault': True}) 
2227          self.__field_items.readfrombuffer(buf) 
2228          self._bufferendoffset=buf.getcurrentoffset() 
2229   
2230   
2231 -    def __getfield_items(self): 
2232          try: self.__field_items 
2233          except: 
2234              self.__field_items=LIST(**{'elementclass': content_entry, 'createdefault': True}) 
2235          return self.__field_items.getvalue() 
2236   
2237 -    def __setfield_items(self, value): 
2238          if isinstance(value,LIST): 
2239              self.__field_items=value 
2240          else: 
2241              self.__field_items=LIST(value,**{'elementclass': content_entry, 'createdefault': True}) 
2242   
2243 -    def __delfield_items(self): del self.__field_items 
2244   
2245      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
2246   
2247 -    def iscontainer(self): 
2248          return True 
2249   
2250 -    def containerelements(self): 
2251          yield ('items', self.__field_items, None) 
2252   
2253   
2254   
2255   
2256 -class content_count(BaseProtogenClass): 
2257      "Stores the number of items in the content file" 
2258      __fields=['count'] 
2259   
2260 -    def __init__(self, *args, **kwargs): 
2261          dict={} 
2262          # What was supplied to this function 
2263          dict.update(kwargs) 
2264          # Parent constructor 
2265          super(content_count,self).__init__(**dict) 
2266          if self.__class__ is content_count: 
2267              self._update(args,dict) 
2268   
2269   
2270 -    def getfields(self): 
2271          return self.__fields 
2272   
2273   
2274 -    def _update(self, args, kwargs): 
2275          super(content_count,self)._update(args,kwargs) 
2276          keys=kwargs.keys() 
2277          for key in keys: 
2278              if key in self.__fields: 
2279                  setattr(self, key, kwargs[key]) 
2280                  del kwargs[key] 
2281          # Were any unrecognized kwargs passed in? 
2282          if __debug__: 
2283              self._complainaboutunusedargs(content_count,kwargs) 
2284          if len(args): 
2285              dict2={'terminator': None} 
2286              dict2.update(kwargs) 
2287              kwargs=dict2 
2288              self.__field_count=USTRING(*args,**dict2) 
2289          # Make all P fields that haven't already been constructed 
2290   
2291   
2292 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2293          'Writes this packet to the supplied buffer' 
2294          self._bufferstartoffset=buf.getcurrentoffset() 
2295          self.__field_count.writetobuffer(buf) 
2296          self._bufferendoffset=buf.getcurrentoffset() 
2297          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2298   
2299   
2300 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2301          'Reads this packet from the supplied buffer' 
2302          self._bufferstartoffset=buf.getcurrentoffset() 
2303          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2304          self.__field_count=USTRING(**{'terminator': None}) 
2305          self.__field_count.readfrombuffer(buf) 
2306          self._bufferendoffset=buf.getcurrentoffset() 
2307   
2308   
2309 -    def __getfield_count(self): 
2310          return self.__field_count.getvalue() 
2311   
2312 -    def __setfield_count(self, value): 
2313          if isinstance(value,USTRING): 
2314              self.__field_count=value 
2315          else: 
2316              self.__field_count=USTRING(value,**{'terminator': None}) 
2317   
2318 -    def __delfield_count(self): del self.__field_count 
2319   
2320      count=property(__getfield_count, __setfield_count, __delfield_count, None) 
2321   
2322 -    def iscontainer(self): 
2323          return True 
2324   
2325 -    def containerelements(self): 
2326          yield ('count', self.__field_count, None) 
2327   
2328   
2329   
2330   
2331 -class textmemo(BaseProtogenClass): 
2332      __fields=['text'] 
2333   
2334 -    def __init__(self, *args, **kwargs): 
2335          dict={} 
2336          # What was supplied to this function 
2337          dict.update(kwargs) 
2338          # Parent constructor 
2339          super(textmemo,self).__init__(**dict) 
2340          if self.__class__ is textmemo: 
2341              self._update(args,dict) 
2342   
2343   
2344 -    def getfields(self): 
2345          return self.__fields 
2346   
2347   
2348 -    def _update(self, args, kwargs): 
2349          super(textmemo,self)._update(args,kwargs) 
2350          keys=kwargs.keys() 
2351          for key in keys: 
2352              if key in self.__fields: 
2353                  setattr(self, key, kwargs[key]) 
2354                  del kwargs[key] 
2355          # Were any unrecognized kwargs passed in? 
2356          if __debug__: 
2357              self._complainaboutunusedargs(textmemo,kwargs) 
2358          if len(args): 
2359              dict2={'sizeinbytes': 151,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False } 
2360              dict2.update(kwargs) 
2361              kwargs=dict2 
2362              self.__field_text=USTRING(*args,**dict2) 
2363          # Make all P fields that haven't already been constructed 
2364   
2365   
2366 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2367          'Writes this packet to the supplied buffer' 
2368          self._bufferstartoffset=buf.getcurrentoffset() 
2369          self.__field_text.writetobuffer(buf) 
2370          self._bufferendoffset=buf.getcurrentoffset() 
2371          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2372   
2373   
2374 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2375          'Reads this packet from the supplied buffer' 
2376          self._bufferstartoffset=buf.getcurrentoffset() 
2377          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2378          self.__field_text=USTRING(**{'sizeinbytes': 151,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False }) 
2379          self.__field_text.readfrombuffer(buf) 
2380          self._bufferendoffset=buf.getcurrentoffset() 
2381   
2382   
2383 -    def __getfield_text(self): 
2384          return self.__field_text.getvalue() 
2385   
2386 -    def __setfield_text(self, value): 
2387          if isinstance(value,USTRING): 
2388              self.__field_text=value 
2389          else: 
2390              self.__field_text=USTRING(value,**{'sizeinbytes': 151,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False }) 
2391   
2392 -    def __delfield_text(self): del self.__field_text 
2393   
2394      text=property(__getfield_text, __setfield_text, __delfield_text, None) 
2395   
2396 -    def iscontainer(self): 
2397          return True 
2398   
2399 -    def containerelements(self): 
2400          yield ('text', self.__field_text, None) 
2401   
2402   
2403   
2404   
2405 -class textmemofile(BaseProtogenClass): 
2406      __fields=['itemcount', 'items'] 
2407   
2408 -    def __init__(self, *args, **kwargs): 
2409          dict={} 
2410          # What was supplied to this function 
2411          dict.update(kwargs) 
2412          # Parent constructor 
2413          super(textmemofile,self).__init__(**dict) 
2414          if self.__class__ is textmemofile: 
2415              self._update(args,dict) 
2416   
2417   
2418 -    def getfields(self): 
2419          return self.__fields 
2420   
2421   
2422 -    def _update(self, args, kwargs): 
2423          super(textmemofile,self)._update(args,kwargs) 
2424          keys=kwargs.keys() 
2425          for key in keys: 
2426              if key in self.__fields: 
2427                  setattr(self, key, kwargs[key]) 
2428                  del kwargs[key] 
2429          # Were any unrecognized kwargs passed in? 
2430          if __debug__: 
2431              self._complainaboutunusedargs(textmemofile,kwargs) 
2432          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2433          # Make all P fields that haven't already been constructed 
2434   
2435   
2436 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2437          'Writes this packet to the supplied buffer' 
2438          self._bufferstartoffset=buf.getcurrentoffset() 
2439          self.__field_itemcount.writetobuffer(buf) 
2440          try: self.__field_items 
2441          except: 
2442              self.__field_items=LIST(**{ 'elementclass': textmemo }) 
2443          self.__field_items.writetobuffer(buf) 
2444          self._bufferendoffset=buf.getcurrentoffset() 
2445          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2446   
2447   
2448 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2449          'Reads this packet from the supplied buffer' 
2450          self._bufferstartoffset=buf.getcurrentoffset() 
2451          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2452          self.__field_itemcount=UINT(**{'sizeinbytes': 4}) 
2453          self.__field_itemcount.readfrombuffer(buf) 
2454          self.__field_items=LIST(**{ 'elementclass': textmemo }) 
2455          self.__field_items.readfrombuffer(buf) 
2456          self._bufferendoffset=buf.getcurrentoffset() 
2457   
2458   
2459 -    def __getfield_itemcount(self): 
2460          return self.__field_itemcount.getvalue() 
2461   
2462 -    def __setfield_itemcount(self, value): 
2463          if isinstance(value,UINT): 
2464              self.__field_itemcount=value 
2465          else: 
2466              self.__field_itemcount=UINT(value,**{'sizeinbytes': 4}) 
2467   
2468 -    def __delfield_itemcount(self): del self.__field_itemcount 
2469   
2470      itemcount=property(__getfield_itemcount, __setfield_itemcount, __delfield_itemcount, None) 
2471   
2472 -    def __getfield_items(self): 
2473          try: self.__field_items 
2474          except: 
2475              self.__field_items=LIST(**{ 'elementclass': textmemo }) 
2476          return self.__field_items.getvalue() 
2477   
2478 -    def __setfield_items(self, value): 
2479          if isinstance(value,LIST): 
2480              self.__field_items=value 
2481          else: 
2482              self.__field_items=LIST(value,**{ 'elementclass': textmemo }) 
2483   
2484 -    def __delfield_items(self): del self.__field_items 
2485   
2486      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
2487   
2488 -    def iscontainer(self): 
2489          return True 
2490   
2491 -    def containerelements(self): 
2492          yield ('itemcount', self.__field_itemcount, None) 
2493          yield ('items', self.__field_items, None) 
2494