Source Code for Module phones.p_lglg6190

   1  # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE 
   2   
   3  """Various descriptions of data specific to LG 6190 (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   
  13  # we are the same as lgvx4400 except as noted 
  14  # below 
  15  from p_lgvx4400 import * 
  16   
  17   
  18  # We use LSB for all integer like fields 
  19  UINT=UINTlsb 
  20  BOOL=BOOLlsb 
  21   
  22  NUMSPEEDDIALS=100 
  23  FIRSTSPEEDDIAL=1 
  24  LASTSPEEDDIAL=99 
  25  NUMPHONEBOOKENTRIES=500 
  26  MEMOLENGTH=65 
  27   
  28  NORINGTONE=0 
  29  NOMSGRINGTONE=0 
  30  NOWALLPAPER=0 
  31   
  32  NUMEMAILS=3 
  33  NUMPHONENUMBERS=5 
  34   
  35  SMS_CANNED_MAX_ITEMS=18 
  36  SMS_CANNED_MAX_LENGTH=101 
  37  SMS_CANNED_FILENAME="sms/mediacan000.dat" 
  38  SMS_PATTERNS={'Inbox': re.compile(r"^.*/inbox[0-9][0-9][0-9]\.dat$"), 
  39               'Sent': re.compile(r"^.*/outbox[0-9][0-9][0-9]\.dat$"), 
  40               'Saved': re.compile(r"^.*/sf[0-9][0-9]\.dat$"), 
  41               } 
  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_NO_VOICE=0xffff 
  82  CAL_REPEAT_DATE=(2999, 12, 31) 
  83   
  84  cal_has_voice_id=True 
  85  cal_voice_id_ofs=0x11 
  86  cal_voice_ext='.qcp'      # full name='sche000.qcp' 
  87   
  88  cal_dir='sch' 
  89  cal_data_file_name='sch/schedule.dat' 
  90  cal_exception_file_name='sch/schexception.dat' 
  91   
  92  PHONE_ENCODING='iso8859_1' 
  93   
  94 -class pbreadentryresponse(BaseProtogenClass): 
  95      "Results of reading one entry" 
  96      __fields=['header', 'entry'] 
  97   
  98 -    def __init__(self, *args, **kwargs): 
  99          dict={} 
 100          # What was supplied to this function 
 101          dict.update(kwargs) 
 102          # Parent constructor 
 103          super(pbreadentryresponse,self).__init__(**dict) 
 104          if self.__class__ is pbreadentryresponse: 
 105              self._update(args,dict) 
 106   
 107   
 108 -    def getfields(self): 
 109          return self.__fields 
 110   
 111   
 112 -    def _update(self, args, kwargs): 
 113          super(pbreadentryresponse,self)._update(args,kwargs) 
 114          keys=kwargs.keys() 
 115          for key in keys: 
 116              if key in self.__fields: 
 117                  setattr(self, key, kwargs[key]) 
 118                  del kwargs[key] 
 119          # Were any unrecognized kwargs passed in? 
 120          if __debug__: 
 121              self._complainaboutunusedargs(pbreadentryresponse,kwargs) 
 122          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 123          # Make all P fields that haven't already been constructed 
 124   
 125   
 126 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 127          'Writes this packet to the supplied buffer' 
 128          self._bufferstartoffset=buf.getcurrentoffset() 
 129          self.__field_header.writetobuffer(buf) 
 130          self.__field_entry.writetobuffer(buf) 
 131          self._bufferendoffset=buf.getcurrentoffset() 
 132          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 133   
 134   
 135 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 136          'Reads this packet from the supplied buffer' 
 137          self._bufferstartoffset=buf.getcurrentoffset() 
 138          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 139          self.__field_header=pbheader() 
 140          self.__field_header.readfrombuffer(buf) 
 141          self.__field_entry=pbentry() 
 142          self.__field_entry.readfrombuffer(buf) 
 143          self._bufferendoffset=buf.getcurrentoffset() 
 144   
 145   
 146 -    def __getfield_header(self): 
 147          return self.__field_header.getvalue() 
 148   
 149 -    def __setfield_header(self, value): 
 150          if isinstance(value,pbheader): 
 151              self.__field_header=value 
 152          else: 
 153              self.__field_header=pbheader(value,) 
 154   
 155 -    def __delfield_header(self): del self.__field_header 
 156   
 157      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
 158   
 159 -    def __getfield_entry(self): 
 160          return self.__field_entry.getvalue() 
 161   
 162 -    def __setfield_entry(self, value): 
 163          if isinstance(value,pbentry): 
 164              self.__field_entry=value 
 165          else: 
 166              self.__field_entry=pbentry(value,) 
 167   
 168 -    def __delfield_entry(self): del self.__field_entry 
 169   
 170      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
 171   
 172 -    def iscontainer(self): 
 173          return True 
 174   
 175 -    def containerelements(self): 
 176          yield ('header', self.__field_header, None) 
 177          yield ('entry', self.__field_entry, None) 
 178   
 179   
 180   
 181   
 182 -class pbupdateentryrequest(BaseProtogenClass): 
 183      __fields=['header', 'entry'] 
 184   
 185 -    def __init__(self, *args, **kwargs): 
 186          dict={} 
 187          # What was supplied to this function 
 188          dict.update(kwargs) 
 189          # Parent constructor 
 190          super(pbupdateentryrequest,self).__init__(**dict) 
 191          if self.__class__ is pbupdateentryrequest: 
 192              self._update(args,dict) 
 193   
 194   
 195 -    def getfields(self): 
 196          return self.__fields 
 197   
 198   
 199 -    def _update(self, args, kwargs): 
 200          super(pbupdateentryrequest,self)._update(args,kwargs) 
 201          keys=kwargs.keys() 
 202          for key in keys: 
 203              if key in self.__fields: 
 204                  setattr(self, key, kwargs[key]) 
 205                  del kwargs[key] 
 206          # Were any unrecognized kwargs passed in? 
 207          if __debug__: 
 208              self._complainaboutunusedargs(pbupdateentryrequest,kwargs) 
 209          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 210          # Make all P fields that haven't already been constructed 
 211   
 212   
 213 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 214          'Writes this packet to the supplied buffer' 
 215          self._bufferstartoffset=buf.getcurrentoffset() 
 216          try: self.__field_header 
 217          except: 
 218              self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01}) 
 219          self.__field_header.writetobuffer(buf) 
 220          self.__field_entry.writetobuffer(buf) 
 221          self._bufferendoffset=buf.getcurrentoffset() 
 222          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 223   
 224   
 225 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 226          'Reads this packet from the supplied buffer' 
 227          self._bufferstartoffset=buf.getcurrentoffset() 
 228          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 229          self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01}) 
 230          self.__field_header.readfrombuffer(buf) 
 231          self.__field_entry=pbentry() 
 232          self.__field_entry.readfrombuffer(buf) 
 233          self._bufferendoffset=buf.getcurrentoffset() 
 234   
 235   
 236 -    def __getfield_header(self): 
 237          try: self.__field_header 
 238          except: 
 239              self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01}) 
 240          return self.__field_header.getvalue() 
 241   
 242 -    def __setfield_header(self, value): 
 243          if isinstance(value,pbheader): 
 244              self.__field_header=value 
 245          else: 
 246              self.__field_header=pbheader(value,**{'command': 0x04, 'flag': 0x01}) 
 247   
 248 -    def __delfield_header(self): del self.__field_header 
 249   
 250      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
 251   
 252 -    def __getfield_entry(self): 
 253          return self.__field_entry.getvalue() 
 254   
 255 -    def __setfield_entry(self, value): 
 256          if isinstance(value,pbentry): 
 257              self.__field_entry=value 
 258          else: 
 259              self.__field_entry=pbentry(value,) 
 260   
 261 -    def __delfield_entry(self): del self.__field_entry 
 262   
 263      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
 264   
 265 -    def iscontainer(self): 
 266          return True 
 267   
 268 -    def containerelements(self): 
 269          yield ('header', self.__field_header, None) 
 270          yield ('entry', self.__field_entry, None) 
 271   
 272   
 273   
 274   
 275 -class pbappendentryrequest(BaseProtogenClass): 
 276      __fields=['header', 'entry'] 
 277   
 278 -    def __init__(self, *args, **kwargs): 
 279          dict={} 
 280          # What was supplied to this function 
 281          dict.update(kwargs) 
 282          # Parent constructor 
 283          super(pbappendentryrequest,self).__init__(**dict) 
 284          if self.__class__ is pbappendentryrequest: 
 285              self._update(args,dict) 
 286   
 287   
 288 -    def getfields(self): 
 289          return self.__fields 
 290   
 291   
 292 -    def _update(self, args, kwargs): 
 293          super(pbappendentryrequest,self)._update(args,kwargs) 
 294          keys=kwargs.keys() 
 295          for key in keys: 
 296              if key in self.__fields: 
 297                  setattr(self, key, kwargs[key]) 
 298                  del kwargs[key] 
 299          # Were any unrecognized kwargs passed in? 
 300          if __debug__: 
 301              self._complainaboutunusedargs(pbappendentryrequest,kwargs) 
 302          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 303          # Make all P fields that haven't already been constructed 
 304   
 305   
 306 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 307          'Writes this packet to the supplied buffer' 
 308          self._bufferstartoffset=buf.getcurrentoffset() 
 309          try: self.__field_header 
 310          except: 
 311              self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01}) 
 312          self.__field_header.writetobuffer(buf) 
 313          self.__field_entry.writetobuffer(buf) 
 314          self._bufferendoffset=buf.getcurrentoffset() 
 315          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 316   
 317   
 318 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 319          'Reads this packet from the supplied buffer' 
 320          self._bufferstartoffset=buf.getcurrentoffset() 
 321          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 322          self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01}) 
 323          self.__field_header.readfrombuffer(buf) 
 324          self.__field_entry=pbentry() 
 325          self.__field_entry.readfrombuffer(buf) 
 326          self._bufferendoffset=buf.getcurrentoffset() 
 327   
 328   
 329 -    def __getfield_header(self): 
 330          try: self.__field_header 
 331          except: 
 332              self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01}) 
 333          return self.__field_header.getvalue() 
 334   
 335 -    def __setfield_header(self, value): 
 336          if isinstance(value,pbheader): 
 337              self.__field_header=value 
 338          else: 
 339              self.__field_header=pbheader(value,**{'command': 0x03, 'flag': 0x01}) 
 340   
 341 -    def __delfield_header(self): del self.__field_header 
 342   
 343      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
 344   
 345 -    def __getfield_entry(self): 
 346          return self.__field_entry.getvalue() 
 347   
 348 -    def __setfield_entry(self, value): 
 349          if isinstance(value,pbentry): 
 350              self.__field_entry=value 
 351          else: 
 352              self.__field_entry=pbentry(value,) 
 353   
 354 -    def __delfield_entry(self): del self.__field_entry 
 355   
 356      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
 357   
 358 -    def iscontainer(self): 
 359          return True 
 360   
 361 -    def containerelements(self): 
 362          yield ('header', self.__field_header, None) 
 363          yield ('entry', self.__field_entry, None) 
 364   
 365   
 366   
 367   
 368 -class speeddial(BaseProtogenClass): 
 369      __fields=['entry', 'number'] 
 370   
 371 -    def __init__(self, *args, **kwargs): 
 372          dict={} 
 373          # What was supplied to this function 
 374          dict.update(kwargs) 
 375          # Parent constructor 
 376          super(speeddial,self).__init__(**dict) 
 377          if self.__class__ is speeddial: 
 378              self._update(args,dict) 
 379   
 380   
 381 -    def getfields(self): 
 382          return self.__fields 
 383   
 384   
 385 -    def _update(self, args, kwargs): 
 386          super(speeddial,self)._update(args,kwargs) 
 387          keys=kwargs.keys() 
 388          for key in keys: 
 389              if key in self.__fields: 
 390                  setattr(self, key, kwargs[key]) 
 391                  del kwargs[key] 
 392          # Were any unrecognized kwargs passed in? 
 393          if __debug__: 
 394              self._complainaboutunusedargs(speeddial,kwargs) 
 395          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 396          # Make all P fields that haven't already been constructed 
 397   
 398   
 399 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 400          'Writes this packet to the supplied buffer' 
 401          self._bufferstartoffset=buf.getcurrentoffset() 
 402          try: self.__field_entry 
 403          except: 
 404              self.__field_entry=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
 405          self.__field_entry.writetobuffer(buf) 
 406          try: self.__field_number 
 407          except: 
 408              self.__field_number=UINT(**{'sizeinbytes': 1, 'default': 0xff}) 
 409          self.__field_number.writetobuffer(buf) 
 410          self._bufferendoffset=buf.getcurrentoffset() 
 411          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 412   
 413   
 414 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 415          'Reads this packet from the supplied buffer' 
 416          self._bufferstartoffset=buf.getcurrentoffset() 
 417          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 418          self.__field_entry=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
 419          self.__field_entry.readfrombuffer(buf) 
 420          self.__field_number=UINT(**{'sizeinbytes': 1, 'default': 0xff}) 
 421          self.__field_number.readfrombuffer(buf) 
 422          self._bufferendoffset=buf.getcurrentoffset() 
 423   
 424   
 425 -    def __getfield_entry(self): 
 426          try: self.__field_entry 
 427          except: 
 428              self.__field_entry=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
 429          return self.__field_entry.getvalue() 
 430   
 431 -    def __setfield_entry(self, value): 
 432          if isinstance(value,UINT): 
 433              self.__field_entry=value 
 434          else: 
 435              self.__field_entry=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff}) 
 436   
 437 -    def __delfield_entry(self): del self.__field_entry 
 438   
 439      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
 440   
 441 -    def __getfield_number(self): 
 442          try: self.__field_number 
 443          except: 
 444              self.__field_number=UINT(**{'sizeinbytes': 1, 'default': 0xff}) 
 445          return self.__field_number.getvalue() 
 446   
 447 -    def __setfield_number(self, value): 
 448          if isinstance(value,UINT): 
 449              self.__field_number=value 
 450          else: 
 451              self.__field_number=UINT(value,**{'sizeinbytes': 1, 'default': 0xff}) 
 452   
 453 -    def __delfield_number(self): del self.__field_number 
 454   
 455      number=property(__getfield_number, __setfield_number, __delfield_number, None) 
 456   
 457 -    def iscontainer(self): 
 458          return True 
 459   
 460 -    def containerelements(self): 
 461          yield ('entry', self.__field_entry, None) 
 462          yield ('number', self.__field_number, None) 
 463   
 464   
 465   
 466   
 467 -class speeddials(BaseProtogenClass): 
 468      __fields=['speeddials'] 
 469   
 470 -    def __init__(self, *args, **kwargs): 
 471          dict={} 
 472          # What was supplied to this function 
 473          dict.update(kwargs) 
 474          # Parent constructor 
 475          super(speeddials,self).__init__(**dict) 
 476          if self.__class__ is speeddials: 
 477              self._update(args,dict) 
 478   
 479   
 480 -    def getfields(self): 
 481          return self.__fields 
 482   
 483   
 484 -    def _update(self, args, kwargs): 
 485          super(speeddials,self)._update(args,kwargs) 
 486          keys=kwargs.keys() 
 487          for key in keys: 
 488              if key in self.__fields: 
 489                  setattr(self, key, kwargs[key]) 
 490                  del kwargs[key] 
 491          # Were any unrecognized kwargs passed in? 
 492          if __debug__: 
 493              self._complainaboutunusedargs(speeddials,kwargs) 
 494          if len(args): 
 495              dict2={'length': NUMSPEEDDIALS, 'elementclass': speeddial} 
 496              dict2.update(kwargs) 
 497              kwargs=dict2 
 498              self.__field_speeddials=LIST(*args,**dict2) 
 499          # Make all P fields that haven't already been constructed 
 500   
 501   
 502 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 503          'Writes this packet to the supplied buffer' 
 504          self._bufferstartoffset=buf.getcurrentoffset() 
 505          try: self.__field_speeddials 
 506          except: 
 507              self.__field_speeddials=LIST(**{'length': NUMSPEEDDIALS, 'elementclass': speeddial}) 
 508          self.__field_speeddials.writetobuffer(buf) 
 509          self._bufferendoffset=buf.getcurrentoffset() 
 510          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 511   
 512   
 513 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 514          'Reads this packet from the supplied buffer' 
 515          self._bufferstartoffset=buf.getcurrentoffset() 
 516          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 517          self.__field_speeddials=LIST(**{'length': NUMSPEEDDIALS, 'elementclass': speeddial}) 
 518          self.__field_speeddials.readfrombuffer(buf) 
 519          self._bufferendoffset=buf.getcurrentoffset() 
 520   
 521   
 522 -    def __getfield_speeddials(self): 
 523          try: self.__field_speeddials 
 524          except: 
 525              self.__field_speeddials=LIST(**{'length': NUMSPEEDDIALS, 'elementclass': speeddial}) 
 526          return self.__field_speeddials.getvalue() 
 527   
 528 -    def __setfield_speeddials(self, value): 
 529          if isinstance(value,LIST): 
 530              self.__field_speeddials=value 
 531          else: 
 532              self.__field_speeddials=LIST(value,**{'length': NUMSPEEDDIALS, 'elementclass': speeddial}) 
 533   
 534 -    def __delfield_speeddials(self): del self.__field_speeddials 
 535   
 536      speeddials=property(__getfield_speeddials, __setfield_speeddials, __delfield_speeddials, None) 
 537   
 538 -    def iscontainer(self): 
 539          return True 
 540   
 541 -    def containerelements(self): 
 542          yield ('speeddials', self.__field_speeddials, None) 
 543   
 544   
 545   
 546   
 547 -class pbentry(BaseProtogenClass): 
 548      __fields=['serial1', 'entrysize', 'serial2', 'entrynumber', 'name', 'group', 'emails', 'url', 'ringtone', 'msgringtone', 'secret', 'memo', 'wallpaper', 'numbertypes', 'numbers', 'unknown20c'] 
 549   
 550 -    def __init__(self, *args, **kwargs): 
 551          dict={} 
 552          # What was supplied to this function 
 553          dict.update(kwargs) 
 554          # Parent constructor 
 555          super(pbentry,self).__init__(**dict) 
 556          if self.__class__ is pbentry: 
 557              self._update(args,dict) 
 558   
 559   
 560 -    def getfields(self): 
 561          return self.__fields 
 562   
 563   
 564 -    def _update(self, args, kwargs): 
 565          super(pbentry,self)._update(args,kwargs) 
 566          keys=kwargs.keys() 
 567          for key in keys: 
 568              if key in self.__fields: 
 569                  setattr(self, key, kwargs[key]) 
 570                  del kwargs[key] 
 571          # Were any unrecognized kwargs passed in? 
 572          if __debug__: 
 573              self._complainaboutunusedargs(pbentry,kwargs) 
 574          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 575          # Make all P fields that haven't already been constructed 
 576   
 577   
 578 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 579          'Writes this packet to the supplied buffer' 
 580          self._bufferstartoffset=buf.getcurrentoffset() 
 581          self.__field_serial1.writetobuffer(buf) 
 582          try: self.__field_entrysize 
 583          except: 
 584              self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0x0222}) 
 585          self.__field_entrysize.writetobuffer(buf) 
 586          self.__field_serial2.writetobuffer(buf) 
 587          self.__field_entrynumber.writetobuffer(buf) 
 588          self.__field_name.writetobuffer(buf) 
 589          self.__field_group.writetobuffer(buf) 
 590          try: self.__field_emails 
 591          except: 
 592              self.__field_emails=LIST(**{'elementclass': _gen_p_lglg6190_137, 'length': NUMEMAILS}) 
 593          self.__field_emails.writetobuffer(buf) 
 594          self.__field_url.writetobuffer(buf) 
 595          self.__field_ringtone.writetobuffer(buf) 
 596          self.__field_msgringtone.writetobuffer(buf) 
 597          self.__field_secret.writetobuffer(buf) 
 598          self.__field_memo.writetobuffer(buf) 
 599          self.__field_wallpaper.writetobuffer(buf) 
 600          try: self.__field_numbertypes 
 601          except: 
 602              self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lglg6190_145, 'length': NUMPHONENUMBERS}) 
 603          self.__field_numbertypes.writetobuffer(buf) 
 604          try: self.__field_numbers 
 605          except: 
 606              self.__field_numbers=LIST(**{'elementclass': _gen_p_lglg6190_147, 'length': NUMPHONENUMBERS}) 
 607          self.__field_numbers.writetobuffer(buf) 
 608          try: self.__field_unknown20c 
 609          except: 
 610              self.__field_unknown20c=UNKNOWN() 
 611          self.__field_unknown20c.writetobuffer(buf) 
 612          self._bufferendoffset=buf.getcurrentoffset() 
 613          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 614   
 615   
 616 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 617          'Reads this packet from the supplied buffer' 
 618          self._bufferstartoffset=buf.getcurrentoffset() 
 619          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 620          self.__field_serial1=UINT(**{'sizeinbytes': 4}) 
 621          self.__field_serial1.readfrombuffer(buf) 
 622          self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0x0222}) 
 623          self.__field_entrysize.readfrombuffer(buf) 
 624          self.__field_serial2=UINT(**{'sizeinbytes': 4}) 
 625          self.__field_serial2.readfrombuffer(buf) 
 626          self.__field_entrynumber=UINT(**{'sizeinbytes': 2}) 
 627          self.__field_entrynumber.readfrombuffer(buf) 
 628          self.__field_name=USTRING(**{'sizeinbytes': 23, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
 629          self.__field_name.readfrombuffer(buf) 
 630          self.__field_group=UINT(**{'sizeinbytes': 2}) 
 631          self.__field_group.readfrombuffer(buf) 
 632          self.__field_emails=LIST(**{'elementclass': _gen_p_lglg6190_137, 'length': NUMEMAILS}) 
 633          self.__field_emails.readfrombuffer(buf) 
 634          self.__field_url=USTRING(**{'sizeinbytes': 49, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
 635          self.__field_url.readfrombuffer(buf) 
 636          self.__field_ringtone=UINT(**{'sizeinbytes': 1}) 
 637          self.__field_ringtone.readfrombuffer(buf) 
 638          self.__field_msgringtone=UINT(**{'sizeinbytes': 1}) 
 639          self.__field_msgringtone.readfrombuffer(buf) 
 640          self.__field_secret=BOOL(**{'sizeinbytes': 1}) 
 641          self.__field_secret.readfrombuffer(buf) 
 642          self.__field_memo=USTRING(**{'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'sizeinbytes': MEMOLENGTH}) 
 643          self.__field_memo.readfrombuffer(buf) 
 644          self.__field_wallpaper=UINT(**{'sizeinbytes': 1}) 
 645          self.__field_wallpaper.readfrombuffer(buf) 
 646          self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lglg6190_145, 'length': NUMPHONENUMBERS}) 
 647          self.__field_numbertypes.readfrombuffer(buf) 
 648          self.__field_numbers=LIST(**{'elementclass': _gen_p_lglg6190_147, 'length': NUMPHONENUMBERS}) 
 649          self.__field_numbers.readfrombuffer(buf) 
 650          self.__field_unknown20c=UNKNOWN() 
 651          self.__field_unknown20c.readfrombuffer(buf) 
 652          self._bufferendoffset=buf.getcurrentoffset() 
 653   
 654   
 655 -    def __getfield_serial1(self): 
 656          return self.__field_serial1.getvalue() 
 657   
 658 -    def __setfield_serial1(self, value): 
 659          if isinstance(value,UINT): 
 660              self.__field_serial1=value 
 661          else: 
 662              self.__field_serial1=UINT(value,**{'sizeinbytes': 4}) 
 663   
 664 -    def __delfield_serial1(self): del self.__field_serial1 
 665   
 666      serial1=property(__getfield_serial1, __setfield_serial1, __delfield_serial1, None) 
 667   
 668 -    def __getfield_entrysize(self): 
 669          try: self.__field_entrysize 
 670          except: 
 671              self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0x0222}) 
 672          return self.__field_entrysize.getvalue() 
 673   
 674 -    def __setfield_entrysize(self, value): 
 675          if isinstance(value,UINT): 
 676              self.__field_entrysize=value 
 677          else: 
 678              self.__field_entrysize=UINT(value,**{'sizeinbytes': 2, 'constant': 0x0222}) 
 679   
 680 -    def __delfield_entrysize(self): del self.__field_entrysize 
 681   
 682      entrysize=property(__getfield_entrysize, __setfield_entrysize, __delfield_entrysize, None) 
 683   
 684 -    def __getfield_serial2(self): 
 685          return self.__field_serial2.getvalue() 
 686   
 687 -    def __setfield_serial2(self, value): 
 688          if isinstance(value,UINT): 
 689              self.__field_serial2=value 
 690          else: 
 691              self.__field_serial2=UINT(value,**{'sizeinbytes': 4}) 
 692   
 693 -    def __delfield_serial2(self): del self.__field_serial2 
 694   
 695      serial2=property(__getfield_serial2, __setfield_serial2, __delfield_serial2, None) 
 696   
 697 -    def __getfield_entrynumber(self): 
 698          return self.__field_entrynumber.getvalue() 
 699   
 700 -    def __setfield_entrynumber(self, value): 
 701          if isinstance(value,UINT): 
 702              self.__field_entrynumber=value 
 703          else: 
 704              self.__field_entrynumber=UINT(value,**{'sizeinbytes': 2}) 
 705   
 706 -    def __delfield_entrynumber(self): del self.__field_entrynumber 
 707   
 708      entrynumber=property(__getfield_entrynumber, __setfield_entrynumber, __delfield_entrynumber, None) 
 709   
 710 -    def __getfield_name(self): 
 711          return self.__field_name.getvalue() 
 712   
 713 -    def __setfield_name(self, value): 
 714          if isinstance(value,USTRING): 
 715              self.__field_name=value 
 716          else: 
 717              self.__field_name=USTRING(value,**{'sizeinbytes': 23, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
 718   
 719 -    def __delfield_name(self): del self.__field_name 
 720   
 721      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
 722   
 723 -    def __getfield_group(self): 
 724          return self.__field_group.getvalue() 
 725   
 726 -    def __setfield_group(self, value): 
 727          if isinstance(value,UINT): 
 728              self.__field_group=value 
 729          else: 
 730              self.__field_group=UINT(value,**{'sizeinbytes': 2}) 
 731   
 732 -    def __delfield_group(self): del self.__field_group 
 733   
 734      group=property(__getfield_group, __setfield_group, __delfield_group, None) 
 735   
 736 -    def __getfield_emails(self): 
 737          try: self.__field_emails 
 738          except: 
 739              self.__field_emails=LIST(**{'elementclass': _gen_p_lglg6190_137, 'length': NUMEMAILS}) 
 740          return self.__field_emails.getvalue() 
 741   
 742 -    def __setfield_emails(self, value): 
 743          if isinstance(value,LIST): 
 744              self.__field_emails=value 
 745          else: 
 746              self.__field_emails=LIST(value,**{'elementclass': _gen_p_lglg6190_137, 'length': NUMEMAILS}) 
 747   
 748 -    def __delfield_emails(self): del self.__field_emails 
 749   
 750      emails=property(__getfield_emails, __setfield_emails, __delfield_emails, None) 
 751   
 752 -    def __getfield_url(self): 
 753          return self.__field_url.getvalue() 
 754   
 755 -    def __setfield_url(self, value): 
 756          if isinstance(value,USTRING): 
 757              self.__field_url=value 
 758          else: 
 759              self.__field_url=USTRING(value,**{'sizeinbytes': 49, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
 760   
 761 -    def __delfield_url(self): del self.__field_url 
 762   
 763      url=property(__getfield_url, __setfield_url, __delfield_url, None) 
 764   
 765 -    def __getfield_ringtone(self): 
 766          return self.__field_ringtone.getvalue() 
 767   
 768 -    def __setfield_ringtone(self, value): 
 769          if isinstance(value,UINT): 
 770              self.__field_ringtone=value 
 771          else: 
 772              self.__field_ringtone=UINT(value,**{'sizeinbytes': 1}) 
 773   
 774 -    def __delfield_ringtone(self): del self.__field_ringtone 
 775   
 776      ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, "ringtone index for a call") 
 777   
 778 -    def __getfield_msgringtone(self): 
 779          return self.__field_msgringtone.getvalue() 
 780   
 781 -    def __setfield_msgringtone(self, value): 
 782          if isinstance(value,UINT): 
 783              self.__field_msgringtone=value 
 784          else: 
 785              self.__field_msgringtone=UINT(value,**{'sizeinbytes': 1}) 
 786   
 787 -    def __delfield_msgringtone(self): del self.__field_msgringtone 
 788   
 789      msgringtone=property(__getfield_msgringtone, __setfield_msgringtone, __delfield_msgringtone, "ringtone index for a text message") 
 790   
 791 -    def __getfield_secret(self): 
 792          return self.__field_secret.getvalue() 
 793   
 794 -    def __setfield_secret(self, value): 
 795          if isinstance(value,BOOL): 
 796              self.__field_secret=value 
 797          else: 
 798              self.__field_secret=BOOL(value,**{'sizeinbytes': 1}) 
 799   
 800 -    def __delfield_secret(self): del self.__field_secret 
 801   
 802      secret=property(__getfield_secret, __setfield_secret, __delfield_secret, None) 
 803   
 804 -    def __getfield_memo(self): 
 805          return self.__field_memo.getvalue() 
 806   
 807 -    def __setfield_memo(self, value): 
 808          if isinstance(value,USTRING): 
 809              self.__field_memo=value 
 810          else: 
 811              self.__field_memo=USTRING(value,**{'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'sizeinbytes': MEMOLENGTH}) 
 812   
 813 -    def __delfield_memo(self): del self.__field_memo 
 814   
 815      memo=property(__getfield_memo, __setfield_memo, __delfield_memo, None) 
 816   
 817 -    def __getfield_wallpaper(self): 
 818          return self.__field_wallpaper.getvalue() 
 819   
 820 -    def __setfield_wallpaper(self, value): 
 821          if isinstance(value,UINT): 
 822              self.__field_wallpaper=value 
 823          else: 
 824              self.__field_wallpaper=UINT(value,**{'sizeinbytes': 1}) 
 825   
 826 -    def __delfield_wallpaper(self): del self.__field_wallpaper 
 827   
 828      wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None) 
 829   
 830 -    def __getfield_numbertypes(self): 
 831          try: self.__field_numbertypes 
 832          except: 
 833              self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lglg6190_145, 'length': NUMPHONENUMBERS}) 
 834          return self.__field_numbertypes.getvalue() 
 835   
 836 -    def __setfield_numbertypes(self, value): 
 837          if isinstance(value,LIST): 
 838              self.__field_numbertypes=value 
 839          else: 
 840              self.__field_numbertypes=LIST(value,**{'elementclass': _gen_p_lglg6190_145, 'length': NUMPHONENUMBERS}) 
 841   
 842 -    def __delfield_numbertypes(self): del self.__field_numbertypes 
 843   
 844      numbertypes=property(__getfield_numbertypes, __setfield_numbertypes, __delfield_numbertypes, None) 
 845   
 846 -    def __getfield_numbers(self): 
 847          try: self.__field_numbers 
 848          except: 
 849              self.__field_numbers=LIST(**{'elementclass': _gen_p_lglg6190_147, 'length': NUMPHONENUMBERS}) 
 850          return self.__field_numbers.getvalue() 
 851   
 852 -    def __setfield_numbers(self, value): 
 853          if isinstance(value,LIST): 
 854              self.__field_numbers=value 
 855          else: 
 856              self.__field_numbers=LIST(value,**{'elementclass': _gen_p_lglg6190_147, 'length': NUMPHONENUMBERS}) 
 857   
 858 -    def __delfield_numbers(self): del self.__field_numbers 
 859   
 860      numbers=property(__getfield_numbers, __setfield_numbers, __delfield_numbers, None) 
 861   
 862 -    def __getfield_unknown20c(self): 
 863          try: self.__field_unknown20c 
 864          except: 
 865              self.__field_unknown20c=UNKNOWN() 
 866          return self.__field_unknown20c.getvalue() 
 867   
 868 -    def __setfield_unknown20c(self, value): 
 869          if isinstance(value,UNKNOWN): 
 870              self.__field_unknown20c=value 
 871          else: 
 872              self.__field_unknown20c=UNKNOWN(value,) 
 873   
 874 -    def __delfield_unknown20c(self): del self.__field_unknown20c 
 875   
 876      unknown20c=property(__getfield_unknown20c, __setfield_unknown20c, __delfield_unknown20c, None) 
 877   
 878 -    def iscontainer(self): 
 879          return True 
 880   
 881 -    def containerelements(self): 
 882          yield ('serial1', self.__field_serial1, None) 
 883          yield ('entrysize', self.__field_entrysize, None) 
 884          yield ('serial2', self.__field_serial2, None) 
 885          yield ('entrynumber', self.__field_entrynumber, None) 
 886          yield ('name', self.__field_name, None) 
 887          yield ('group', self.__field_group, None) 
 888          yield ('emails', self.__field_emails, None) 
 889          yield ('url', self.__field_url, None) 
 890          yield ('ringtone', self.__field_ringtone, "ringtone index for a call") 
 891          yield ('msgringtone', self.__field_msgringtone, "ringtone index for a text message") 
 892          yield ('secret', self.__field_secret, None) 
 893          yield ('memo', self.__field_memo, None) 
 894          yield ('wallpaper', self.__field_wallpaper, None) 
 895          yield ('numbertypes', self.__field_numbertypes, None) 
 896          yield ('numbers', self.__field_numbers, None) 
 897          yield ('unknown20c', self.__field_unknown20c, None) 
 898   
 899   
 900   
 901   
 902 -class _gen_p_lglg6190_137(BaseProtogenClass): 
 903      'Anonymous inner class' 
 904      __fields=['email'] 
 905   
 906 -    def __init__(self, *args, **kwargs): 
 907          dict={} 
 908          # What was supplied to this function 
 909          dict.update(kwargs) 
 910          # Parent constructor 
 911          super(_gen_p_lglg6190_137,self).__init__(**dict) 
 912          if self.__class__ is _gen_p_lglg6190_137: 
 913              self._update(args,dict) 
 914   
 915   
 916 -    def getfields(self): 
 917          return self.__fields 
 918   
 919   
 920 -    def _update(self, args, kwargs): 
 921          super(_gen_p_lglg6190_137,self)._update(args,kwargs) 
 922          keys=kwargs.keys() 
 923          for key in keys: 
 924              if key in self.__fields: 
 925                  setattr(self, key, kwargs[key]) 
 926                  del kwargs[key] 
 927          # Were any unrecognized kwargs passed in? 
 928          if __debug__: 
 929              self._complainaboutunusedargs(_gen_p_lglg6190_137,kwargs) 
 930          if len(args): 
 931              dict2={'sizeinbytes': 49, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False} 
 932              dict2.update(kwargs) 
 933              kwargs=dict2 
 934              self.__field_email=USTRING(*args,**dict2) 
 935          # Make all P fields that haven't already been constructed 
 936   
 937   
 938 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 939          'Writes this packet to the supplied buffer' 
 940          self._bufferstartoffset=buf.getcurrentoffset() 
 941          self.__field_email.writetobuffer(buf) 
 942          self._bufferendoffset=buf.getcurrentoffset() 
 943          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 944   
 945   
 946 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 947          'Reads this packet from the supplied buffer' 
 948          self._bufferstartoffset=buf.getcurrentoffset() 
 949          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 950          self.__field_email=USTRING(**{'sizeinbytes': 49, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
 951          self.__field_email.readfrombuffer(buf) 
 952          self._bufferendoffset=buf.getcurrentoffset() 
 953   
 954   
 955 -    def __getfield_email(self): 
 956          return self.__field_email.getvalue() 
 957   
 958 -    def __setfield_email(self, value): 
 959          if isinstance(value,USTRING): 
 960              self.__field_email=value 
 961          else: 
 962              self.__field_email=USTRING(value,**{'sizeinbytes': 49, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
 963   
 964 -    def __delfield_email(self): del self.__field_email 
 965   
 966      email=property(__getfield_email, __setfield_email, __delfield_email, None) 
 967   
 968 -    def iscontainer(self): 
 969          return True 
 970   
 971 -    def containerelements(self): 
 972          yield ('email', self.__field_email, None) 
 973   
 974   
 975   
 976   
 977 -class _gen_p_lglg6190_145(BaseProtogenClass): 
 978      'Anonymous inner class' 
 979      __fields=['numbertype'] 
 980   
 981 -    def __init__(self, *args, **kwargs): 
 982          dict={} 
 983          # What was supplied to this function 
 984          dict.update(kwargs) 
 985          # Parent constructor 
 986          super(_gen_p_lglg6190_145,self).__init__(**dict) 
 987          if self.__class__ is _gen_p_lglg6190_145: 
 988              self._update(args,dict) 
 989   
 990   
 991 -    def getfields(self): 
 992          return self.__fields 
 993   
 994   
 995 -    def _update(self, args, kwargs): 
 996          super(_gen_p_lglg6190_145,self)._update(args,kwargs) 
 997          keys=kwargs.keys() 
 998          for key in keys: 
 999              if key in self.__fields: 
1000                  setattr(self, key, kwargs[key]) 
1001                  del kwargs[key] 
1002          # Were any unrecognized kwargs passed in? 
1003          if __debug__: 
1004              self._complainaboutunusedargs(_gen_p_lglg6190_145,kwargs) 
1005          if len(args): 
1006              dict2={'sizeinbytes': 1} 
1007              dict2.update(kwargs) 
1008              kwargs=dict2 
1009              self.__field_numbertype=UINT(*args,**dict2) 
1010          # Make all P fields that haven't already been constructed 
1011   
1012   
1013 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1014          'Writes this packet to the supplied buffer' 
1015          self._bufferstartoffset=buf.getcurrentoffset() 
1016          self.__field_numbertype.writetobuffer(buf) 
1017          self._bufferendoffset=buf.getcurrentoffset() 
1018          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1019   
1020   
1021 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1022          'Reads this packet from the supplied buffer' 
1023          self._bufferstartoffset=buf.getcurrentoffset() 
1024          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1025          self.__field_numbertype=UINT(**{'sizeinbytes': 1}) 
1026          self.__field_numbertype.readfrombuffer(buf) 
1027          self._bufferendoffset=buf.getcurrentoffset() 
1028   
1029   
1030 -    def __getfield_numbertype(self): 
1031          return self.__field_numbertype.getvalue() 
1032   
1033 -    def __setfield_numbertype(self, value): 
1034          if isinstance(value,UINT): 
1035              self.__field_numbertype=value 
1036          else: 
1037              self.__field_numbertype=UINT(value,**{'sizeinbytes': 1}) 
1038   
1039 -    def __delfield_numbertype(self): del self.__field_numbertype 
1040   
1041      numbertype=property(__getfield_numbertype, __setfield_numbertype, __delfield_numbertype, None) 
1042   
1043 -    def iscontainer(self): 
1044          return True 
1045   
1046 -    def containerelements(self): 
1047          yield ('numbertype', self.__field_numbertype, None) 
1048   
1049   
1050   
1051   
1052 -class _gen_p_lglg6190_147(BaseProtogenClass): 
1053      'Anonymous inner class' 
1054      __fields=['number'] 
1055   
1056 -    def __init__(self, *args, **kwargs): 
1057          dict={} 
1058          # What was supplied to this function 
1059          dict.update(kwargs) 
1060          # Parent constructor 
1061          super(_gen_p_lglg6190_147,self).__init__(**dict) 
1062          if self.__class__ is _gen_p_lglg6190_147: 
1063              self._update(args,dict) 
1064   
1065   
1066 -    def getfields(self): 
1067          return self.__fields 
1068   
1069   
1070 -    def _update(self, args, kwargs): 
1071          super(_gen_p_lglg6190_147,self)._update(args,kwargs) 
1072          keys=kwargs.keys() 
1073          for key in keys: 
1074              if key in self.__fields: 
1075                  setattr(self, key, kwargs[key]) 
1076                  del kwargs[key] 
1077          # Were any unrecognized kwargs passed in? 
1078          if __debug__: 
1079              self._complainaboutunusedargs(_gen_p_lglg6190_147,kwargs) 
1080          if len(args): 
1081              dict2={'sizeinbytes': 49, 'raiseonunterminatedread': False} 
1082              dict2.update(kwargs) 
1083              kwargs=dict2 
1084              self.__field_number=USTRING(*args,**dict2) 
1085          # Make all P fields that haven't already been constructed 
1086   
1087   
1088 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1089          'Writes this packet to the supplied buffer' 
1090          self._bufferstartoffset=buf.getcurrentoffset() 
1091          self.__field_number.writetobuffer(buf) 
1092          self._bufferendoffset=buf.getcurrentoffset() 
1093          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1094   
1095   
1096 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1097          'Reads this packet from the supplied buffer' 
1098          self._bufferstartoffset=buf.getcurrentoffset() 
1099          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1100          self.__field_number=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 
1101          self.__field_number.readfrombuffer(buf) 
1102          self._bufferendoffset=buf.getcurrentoffset() 
1103   
1104   
1105 -    def __getfield_number(self): 
1106          return self.__field_number.getvalue() 
1107   
1108 -    def __setfield_number(self, value): 
1109          if isinstance(value,USTRING): 
1110              self.__field_number=value 
1111          else: 
1112              self.__field_number=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 
1113   
1114 -    def __delfield_number(self): del self.__field_number 
1115   
1116      number=property(__getfield_number, __setfield_number, __delfield_number, None) 
1117   
1118 -    def iscontainer(self): 
1119          return True 
1120   
1121 -    def containerelements(self): 
1122          yield ('number', self.__field_number, None) 
1123   
1124   
1125   
1126   
1127 -class pbgroup(BaseProtogenClass): 
1128      "A single group" 
1129      __fields=['icon', 'name'] 
1130   
1131 -    def __init__(self, *args, **kwargs): 
1132          dict={} 
1133          # What was supplied to this function 
1134          dict.update(kwargs) 
1135          # Parent constructor 
1136          super(pbgroup,self).__init__(**dict) 
1137          if self.__class__ is pbgroup: 
1138              self._update(args,dict) 
1139   
1140   
1141 -    def getfields(self): 
1142          return self.__fields 
1143   
1144   
1145 -    def _update(self, args, kwargs): 
1146          super(pbgroup,self)._update(args,kwargs) 
1147          keys=kwargs.keys() 
1148          for key in keys: 
1149              if key in self.__fields: 
1150                  setattr(self, key, kwargs[key]) 
1151                  del kwargs[key] 
1152          # Were any unrecognized kwargs passed in? 
1153          if __debug__: 
1154              self._complainaboutunusedargs(pbgroup,kwargs) 
1155          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1156          # Make all P fields that haven't already been constructed 
1157   
1158   
1159 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1160          'Writes this packet to the supplied buffer' 
1161          self._bufferstartoffset=buf.getcurrentoffset() 
1162          self.__field_icon.writetobuffer(buf) 
1163          self.__field_name.writetobuffer(buf) 
1164          self._bufferendoffset=buf.getcurrentoffset() 
1165          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1166   
1167   
1168 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1169          'Reads this packet from the supplied buffer' 
1170          self._bufferstartoffset=buf.getcurrentoffset() 
1171          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1172          self.__field_icon=UINT(**{'sizeinbytes': 1}) 
1173          self.__field_icon.readfrombuffer(buf) 
1174          self.__field_name=USTRING(**{'sizeinbytes': 23, 'encoding': PHONE_ENCODING}) 
1175          self.__field_name.readfrombuffer(buf) 
1176          self._bufferendoffset=buf.getcurrentoffset() 
1177   
1178   
1179 -    def __getfield_icon(self): 
1180          return self.__field_icon.getvalue() 
1181   
1182 -    def __setfield_icon(self, value): 
1183          if isinstance(value,UINT): 
1184              self.__field_icon=value 
1185          else: 
1186              self.__field_icon=UINT(value,**{'sizeinbytes': 1}) 
1187   
1188 -    def __delfield_icon(self): del self.__field_icon 
1189   
1190      icon=property(__getfield_icon, __setfield_icon, __delfield_icon, None) 
1191   
1192 -    def __getfield_name(self): 
1193          return self.__field_name.getvalue() 
1194   
1195 -    def __setfield_name(self, value): 
1196          if isinstance(value,USTRING): 
1197              self.__field_name=value 
1198          else: 
1199              self.__field_name=USTRING(value,**{'sizeinbytes': 23, 'encoding': PHONE_ENCODING}) 
1200   
1201 -    def __delfield_name(self): del self.__field_name 
1202   
1203      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
1204   
1205 -    def iscontainer(self): 
1206          return True 
1207   
1208 -    def containerelements(self): 
1209          yield ('icon', self.__field_icon, None) 
1210          yield ('name', self.__field_name, None) 
1211   
1212   
1213   
1214   
1215 -class pbgroups(BaseProtogenClass): 
1216      "Phonebook groups" 
1217      __fields=['groups'] 
1218   
1219 -    def __init__(self, *args, **kwargs): 
1220          dict={} 
1221          # What was supplied to this function 
1222          dict.update(kwargs) 
1223          # Parent constructor 
1224          super(pbgroups,self).__init__(**dict) 
1225          if self.__class__ is pbgroups: 
1226              self._update(args,dict) 
1227   
1228   
1229 -    def getfields(self): 
1230          return self.__fields 
1231   
1232   
1233 -    def _update(self, args, kwargs): 
1234          super(pbgroups,self)._update(args,kwargs) 
1235          keys=kwargs.keys() 
1236          for key in keys: 
1237              if key in self.__fields: 
1238                  setattr(self, key, kwargs[key]) 
1239                  del kwargs[key] 
1240          # Were any unrecognized kwargs passed in? 
1241          if __debug__: 
1242              self._complainaboutunusedargs(pbgroups,kwargs) 
1243          if len(args): 
1244              dict2={'elementclass': pbgroup} 
1245              dict2.update(kwargs) 
1246              kwargs=dict2 
1247              self.__field_groups=LIST(*args,**dict2) 
1248          # Make all P fields that haven't already been constructed 
1249   
1250   
1251 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1252          'Writes this packet to the supplied buffer' 
1253          self._bufferstartoffset=buf.getcurrentoffset() 
1254          try: self.__field_groups 
1255          except: 
1256              self.__field_groups=LIST(**{'elementclass': pbgroup}) 
1257          self.__field_groups.writetobuffer(buf) 
1258          self._bufferendoffset=buf.getcurrentoffset() 
1259          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1260   
1261   
1262 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1263          'Reads this packet from the supplied buffer' 
1264          self._bufferstartoffset=buf.getcurrentoffset() 
1265          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1266          self.__field_groups=LIST(**{'elementclass': pbgroup}) 
1267          self.__field_groups.readfrombuffer(buf) 
1268          self._bufferendoffset=buf.getcurrentoffset() 
1269   
1270   
1271 -    def __getfield_groups(self): 
1272          try: self.__field_groups 
1273          except: 
1274              self.__field_groups=LIST(**{'elementclass': pbgroup}) 
1275          return self.__field_groups.getvalue() 
1276   
1277 -    def __setfield_groups(self, value): 
1278          if isinstance(value,LIST): 
1279              self.__field_groups=value 
1280          else: 
1281              self.__field_groups=LIST(value,**{'elementclass': pbgroup}) 
1282   
1283 -    def __delfield_groups(self): del self.__field_groups 
1284   
1285      groups=property(__getfield_groups, __setfield_groups, __delfield_groups, None) 
1286   
1287 -    def iscontainer(self): 
1288          return True 
1289   
1290 -    def containerelements(self): 
1291          yield ('groups', self.__field_groups, None) 
1292   
1293   
1294   
1295   
1296 -class call(BaseProtogenClass): 
1297      __fields=['GPStime', 'unknown1', 'duration', 'number', 'name', 'numberlength', 'unknown2', 'pbnumbertype', 'unknown3', 'pbentrynum'] 
1298   
1299 -    def __init__(self, *args, **kwargs): 
1300          dict={} 
1301          # What was supplied to this function 
1302          dict.update(kwargs) 
1303          # Parent constructor 
1304          super(call,self).__init__(**dict) 
1305          if self.__class__ is call: 
1306              self._update(args,dict) 
1307   
1308   
1309 -    def getfields(self): 
1310          return self.__fields 
1311   
1312   
1313 -    def _update(self, args, kwargs): 
1314          super(call,self)._update(args,kwargs) 
1315          keys=kwargs.keys() 
1316          for key in keys: 
1317              if key in self.__fields: 
1318                  setattr(self, key, kwargs[key]) 
1319                  del kwargs[key] 
1320          # Were any unrecognized kwargs passed in? 
1321          if __debug__: 
1322              self._complainaboutunusedargs(call,kwargs) 
1323          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1324          # Make all P fields that haven't already been constructed 
1325   
1326   
1327 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1328          'Writes this packet to the supplied buffer' 
1329          self._bufferstartoffset=buf.getcurrentoffset() 
1330          self.__field_GPStime.writetobuffer(buf) 
1331          self.__field_unknown1.writetobuffer(buf) 
1332          self.__field_duration.writetobuffer(buf) 
1333          self.__field_number.writetobuffer(buf) 
1334          self.__field_name.writetobuffer(buf) 
1335          self.__field_numberlength.writetobuffer(buf) 
1336          self.__field_unknown2.writetobuffer(buf) 
1337          self.__field_pbnumbertype.writetobuffer(buf) 
1338          self.__field_unknown3.writetobuffer(buf) 
1339          self.__field_pbentrynum.writetobuffer(buf) 
1340          self._bufferendoffset=buf.getcurrentoffset() 
1341          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1342   
1343   
1344 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1345          'Reads this packet from the supplied buffer' 
1346          self._bufferstartoffset=buf.getcurrentoffset() 
1347          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1348          self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4}) 
1349          self.__field_GPStime.readfrombuffer(buf) 
1350          self.__field_unknown1=UINT(**{'sizeinbytes': 4}) 
1351          self.__field_unknown1.readfrombuffer(buf) 
1352          self.__field_duration=UINT(**{'sizeinbytes': 4}) 
1353          self.__field_duration.readfrombuffer(buf) 
1354          self.__field_number=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 
1355          self.__field_number.readfrombuffer(buf) 
1356          self.__field_name=USTRING(**{'sizeinbytes': 36, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
1357          self.__field_name.readfrombuffer(buf) 
1358          self.__field_numberlength=UINT(**{'sizeinbytes': 1}) 
1359          self.__field_numberlength.readfrombuffer(buf) 
1360          self.__field_unknown2=UINT(**{'sizeinbytes': 1}) 
1361          self.__field_unknown2.readfrombuffer(buf) 
1362          self.__field_pbnumbertype=UINT(**{'sizeinbytes': 1}) 
1363          self.__field_pbnumbertype.readfrombuffer(buf) 
1364          self.__field_unknown3=UINT(**{'sizeinbytes': 2}) 
1365          self.__field_unknown3.readfrombuffer(buf) 
1366          self.__field_pbentrynum=UINT(**{'sizeinbytes': 2}) 
1367          self.__field_pbentrynum.readfrombuffer(buf) 
1368          self._bufferendoffset=buf.getcurrentoffset() 
1369   
1370   
1371 -    def __getfield_GPStime(self): 
1372          return self.__field_GPStime.getvalue() 
1373   
1374 -    def __setfield_GPStime(self, value): 
1375          if isinstance(value,GPSDATE): 
1376              self.__field_GPStime=value 
1377          else: 
1378              self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4}) 
1379   
1380 -    def __delfield_GPStime(self): del self.__field_GPStime 
1381   
1382      GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None) 
1383   
1384 -    def __getfield_unknown1(self): 
1385          return self.__field_unknown1.getvalue() 
1386   
1387 -    def __setfield_unknown1(self, value): 
1388          if isinstance(value,UINT): 
1389              self.__field_unknown1=value 
1390          else: 
1391              self.__field_unknown1=UINT(value,**{'sizeinbytes': 4}) 
1392   
1393 -    def __delfield_unknown1(self): del self.__field_unknown1 
1394   
1395      unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 
1396   
1397 -    def __getfield_duration(self): 
1398          return self.__field_duration.getvalue() 
1399   
1400 -    def __setfield_duration(self, value): 
1401          if isinstance(value,UINT): 
1402              self.__field_duration=value 
1403          else: 
1404              self.__field_duration=UINT(value,**{'sizeinbytes': 4}) 
1405   
1406 -    def __delfield_duration(self): del self.__field_duration 
1407   
1408      duration=property(__getfield_duration, __setfield_duration, __delfield_duration, None) 
1409   
1410 -    def __getfield_number(self): 
1411          return self.__field_number.getvalue() 
1412   
1413 -    def __setfield_number(self, value): 
1414          if isinstance(value,USTRING): 
1415              self.__field_number=value 
1416          else: 
1417              self.__field_number=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 
1418   
1419 -    def __delfield_number(self): del self.__field_number 
1420   
1421      number=property(__getfield_number, __setfield_number, __delfield_number, None) 
1422   
1423 -    def __getfield_name(self): 
1424          return self.__field_name.getvalue() 
1425   
1426 -    def __setfield_name(self, value): 
1427          if isinstance(value,USTRING): 
1428              self.__field_name=value 
1429          else: 
1430              self.__field_name=USTRING(value,**{'sizeinbytes': 36, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
1431   
1432 -    def __delfield_name(self): del self.__field_name 
1433   
1434      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
1435   
1436 -    def __getfield_numberlength(self): 
1437          return self.__field_numberlength.getvalue() 
1438   
1439 -    def __setfield_numberlength(self, value): 
1440          if isinstance(value,UINT): 
1441              self.__field_numberlength=value 
1442          else: 
1443              self.__field_numberlength=UINT(value,**{'sizeinbytes': 1}) 
1444   
1445 -    def __delfield_numberlength(self): del self.__field_numberlength 
1446   
1447      numberlength=property(__getfield_numberlength, __setfield_numberlength, __delfield_numberlength, None) 
1448   
1449 -    def __getfield_unknown2(self): 
1450          return self.__field_unknown2.getvalue() 
1451   
1452 -    def __setfield_unknown2(self, value): 
1453          if isinstance(value,UINT): 
1454              self.__field_unknown2=value 
1455          else: 
1456              self.__field_unknown2=UINT(value,**{'sizeinbytes': 1}) 
1457   
1458 -    def __delfield_unknown2(self): del self.__field_unknown2 
1459   
1460      unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None) 
1461   
1462 -    def __getfield_pbnumbertype(self): 
1463          return self.__field_pbnumbertype.getvalue() 
1464   
1465 -    def __setfield_pbnumbertype(self, value): 
1466          if isinstance(value,UINT): 
1467              self.__field_pbnumbertype=value 
1468          else: 
1469              self.__field_pbnumbertype=UINT(value,**{'sizeinbytes': 1}) 
1470   
1471 -    def __delfield_pbnumbertype(self): del self.__field_pbnumbertype 
1472   
1473      pbnumbertype=property(__getfield_pbnumbertype, __setfield_pbnumbertype, __delfield_pbnumbertype, None) 
1474   
1475 -    def __getfield_unknown3(self): 
1476          return self.__field_unknown3.getvalue() 
1477   
1478 -    def __setfield_unknown3(self, value): 
1479          if isinstance(value,UINT): 
1480              self.__field_unknown3=value 
1481          else: 
1482              self.__field_unknown3=UINT(value,**{'sizeinbytes': 2}) 
1483   
1484 -    def __delfield_unknown3(self): del self.__field_unknown3 
1485   
1486      unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None) 
1487   
1488 -    def __getfield_pbentrynum(self): 
1489          return self.__field_pbentrynum.getvalue() 
1490   
1491 -    def __setfield_pbentrynum(self, value): 
1492          if isinstance(value,UINT): 
1493              self.__field_pbentrynum=value 
1494          else: 
1495              self.__field_pbentrynum=UINT(value,**{'sizeinbytes': 2}) 
1496   
1497 -    def __delfield_pbentrynum(self): del self.__field_pbentrynum 
1498   
1499      pbentrynum=property(__getfield_pbentrynum, __setfield_pbentrynum, __delfield_pbentrynum, None) 
1500   
1501 -    def iscontainer(self): 
1502          return True 
1503   
1504 -    def containerelements(self): 
1505          yield ('GPStime', self.__field_GPStime, None) 
1506          yield ('unknown1', self.__field_unknown1, None) 
1507          yield ('duration', self.__field_duration, None) 
1508          yield ('number', self.__field_number, None) 
1509          yield ('name', self.__field_name, None) 
1510          yield ('numberlength', self.__field_numberlength, None) 
1511          yield ('unknown2', self.__field_unknown2, None) 
1512          yield ('pbnumbertype', self.__field_pbnumbertype, None) 
1513          yield ('unknown3', self.__field_unknown3, None) 
1514          yield ('pbentrynum', self.__field_pbentrynum, None) 
1515   
1516   
1517   
1518   
1519 -class callhistory(BaseProtogenClass): 
1520      __fields=['numcalls', 'unknown1', 'calls'] 
1521   
1522 -    def __init__(self, *args, **kwargs): 
1523          dict={} 
1524          # What was supplied to this function 
1525          dict.update(kwargs) 
1526          # Parent constructor 
1527          super(callhistory,self).__init__(**dict) 
1528          if self.__class__ is callhistory: 
1529              self._update(args,dict) 
1530   
1531   
1532 -    def getfields(self): 
1533          return self.__fields 
1534   
1535   
1536 -    def _update(self, args, kwargs): 
1537          super(callhistory,self)._update(args,kwargs) 
1538          keys=kwargs.keys() 
1539          for key in keys: 
1540              if key in self.__fields: 
1541                  setattr(self, key, kwargs[key]) 
1542                  del kwargs[key] 
1543          # Were any unrecognized kwargs passed in? 
1544          if __debug__: 
1545              self._complainaboutunusedargs(callhistory,kwargs) 
1546          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1547          # Make all P fields that haven't already been constructed 
1548   
1549   
1550 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1551          'Writes this packet to the supplied buffer' 
1552          self._bufferstartoffset=buf.getcurrentoffset() 
1553          self.__field_numcalls.writetobuffer(buf) 
1554          self.__field_unknown1.writetobuffer(buf) 
1555          try: self.__field_calls 
1556          except: 
1557              self.__field_calls=LIST(**{'elementclass': call}) 
1558          self.__field_calls.writetobuffer(buf) 
1559          self._bufferendoffset=buf.getcurrentoffset() 
1560          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1561   
1562   
1563 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1564          'Reads this packet from the supplied buffer' 
1565          self._bufferstartoffset=buf.getcurrentoffset() 
1566          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1567          self.__field_numcalls=UINT(**{'sizeinbytes': 4}) 
1568          self.__field_numcalls.readfrombuffer(buf) 
1569          self.__field_unknown1=UINT(**{'sizeinbytes': 1}) 
1570          self.__field_unknown1.readfrombuffer(buf) 
1571          self.__field_calls=LIST(**{'elementclass': call}) 
1572          self.__field_calls.readfrombuffer(buf) 
1573          self._bufferendoffset=buf.getcurrentoffset() 
1574   
1575   
1576 -    def __getfield_numcalls(self): 
1577          return self.__field_numcalls.getvalue() 
1578   
1579 -    def __setfield_numcalls(self, value): 
1580          if isinstance(value,UINT): 
1581              self.__field_numcalls=value 
1582          else: 
1583              self.__field_numcalls=UINT(value,**{'sizeinbytes': 4}) 
1584   
1585 -    def __delfield_numcalls(self): del self.__field_numcalls 
1586   
1587      numcalls=property(__getfield_numcalls, __setfield_numcalls, __delfield_numcalls, None) 
1588   
1589 -    def __getfield_unknown1(self): 
1590          return self.__field_unknown1.getvalue() 
1591   
1592 -    def __setfield_unknown1(self, value): 
1593          if isinstance(value,UINT): 
1594              self.__field_unknown1=value 
1595          else: 
1596              self.__field_unknown1=UINT(value,**{'sizeinbytes': 1}) 
1597   
1598 -    def __delfield_unknown1(self): del self.__field_unknown1 
1599   
1600      unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 
1601   
1602 -    def __getfield_calls(self): 
1603          try: self.__field_calls 
1604          except: 
1605              self.__field_calls=LIST(**{'elementclass': call}) 
1606          return self.__field_calls.getvalue() 
1607   
1608 -    def __setfield_calls(self, value): 
1609          if isinstance(value,LIST): 
1610              self.__field_calls=value 
1611          else: 
1612              self.__field_calls=LIST(value,**{'elementclass': call}) 
1613   
1614 -    def __delfield_calls(self): del self.__field_calls 
1615   
1616      calls=property(__getfield_calls, __setfield_calls, __delfield_calls, None) 
1617   
1618 -    def iscontainer(self): 
1619          return True 
1620   
1621 -    def containerelements(self): 
1622          yield ('numcalls', self.__field_numcalls, None) 
1623          yield ('unknown1', self.__field_unknown1, None) 
1624          yield ('calls', self.__field_calls, None) 
1625   
1626   
1627   
1628   
1629 -class indexentry(BaseProtogenClass): 
1630      __fields=['index', 'name'] 
1631   
1632 -    def __init__(self, *args, **kwargs): 
1633          dict={} 
1634          # What was supplied to this function 
1635          dict.update(kwargs) 
1636          # Parent constructor 
1637          super(indexentry,self).__init__(**dict) 
1638          if self.__class__ is indexentry: 
1639              self._update(args,dict) 
1640   
1641   
1642 -    def getfields(self): 
1643          return self.__fields 
1644   
1645   
1646 -    def _update(self, args, kwargs): 
1647          super(indexentry,self)._update(args,kwargs) 
1648          keys=kwargs.keys() 
1649          for key in keys: 
1650              if key in self.__fields: 
1651                  setattr(self, key, kwargs[key]) 
1652                  del kwargs[key] 
1653          # Were any unrecognized kwargs passed in? 
1654          if __debug__: 
1655              self._complainaboutunusedargs(indexentry,kwargs) 
1656          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1657          # Make all P fields that haven't already been constructed 
1658   
1659   
1660 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1661          'Writes this packet to the supplied buffer' 
1662          self._bufferstartoffset=buf.getcurrentoffset() 
1663          try: self.__field_index 
1664          except: 
1665              self.__field_index=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
1666          self.__field_index.writetobuffer(buf) 
1667          try: self.__field_name 
1668          except: 
1669              self.__field_name=USTRING(**{'sizeinbytes': 50, 'default': ""}) 
1670          self.__field_name.writetobuffer(buf) 
1671          self._bufferendoffset=buf.getcurrentoffset() 
1672          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1673   
1674   
1675 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1676          'Reads this packet from the supplied buffer' 
1677          self._bufferstartoffset=buf.getcurrentoffset() 
1678          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1679          self.__field_index=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
1680          self.__field_index.readfrombuffer(buf) 
1681          self.__field_name=USTRING(**{'sizeinbytes': 50, 'default': ""}) 
1682          self.__field_name.readfrombuffer(buf) 
1683          self._bufferendoffset=buf.getcurrentoffset() 
1684   
1685   
1686 -    def __getfield_index(self): 
1687          try: self.__field_index 
1688          except: 
1689              self.__field_index=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
1690          return self.__field_index.getvalue() 
1691   
1692 -    def __setfield_index(self, value): 
1693          if isinstance(value,UINT): 
1694              self.__field_index=value 
1695          else: 
1696              self.__field_index=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff}) 
1697   
1698 -    def __delfield_index(self): del self.__field_index 
1699   
1700      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
1701   
1702 -    def __getfield_name(self): 
1703          try: self.__field_name 
1704          except: 
1705              self.__field_name=USTRING(**{'sizeinbytes': 50, 'default': ""}) 
1706          return self.__field_name.getvalue() 
1707   
1708 -    def __setfield_name(self, value): 
1709          if isinstance(value,USTRING): 
1710              self.__field_name=value 
1711          else: 
1712              self.__field_name=USTRING(value,**{'sizeinbytes': 50, 'default': ""}) 
1713   
1714 -    def __delfield_name(self): del self.__field_name 
1715   
1716      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
1717   
1718 -    def iscontainer(self): 
1719          return True 
1720   
1721 -    def containerelements(self): 
1722          yield ('index', self.__field_index, None) 
1723          yield ('name', self.__field_name, None) 
1724   
1725   
1726   
1727   
1728 -class indexfile(BaseProtogenClass): 
1729      "Used for tracking wallpaper and ringtones" 
1730      __fields=['maxitems', 'numactiveitems', 'items'] 
1731   
1732 -    def __init__(self, *args, **kwargs): 
1733          dict={} 
1734          # What was supplied to this function 
1735          dict.update(kwargs) 
1736          # Parent constructor 
1737          super(indexfile,self).__init__(**dict) 
1738          if self.__class__ is indexfile: 
1739              self._update(args,dict) 
1740   
1741   
1742 -    def getfields(self): 
1743          return self.__fields 
1744   
1745   
1746 -    def _update(self, args, kwargs): 
1747          super(indexfile,self)._update(args,kwargs) 
1748          keys=kwargs.keys() 
1749          for key in keys: 
1750              if key in self.__fields: 
1751                  setattr(self, key, kwargs[key]) 
1752                  del kwargs[key] 
1753          # Were any unrecognized kwargs passed in? 
1754          if __debug__: 
1755              self._complainaboutunusedargs(indexfile,kwargs) 
1756          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1757          # Make all P fields that haven't already been constructed 
1758          try: self.__field_maxitems 
1759          except: 
1760              self.__field_maxitems=UINT(**{'constant': 30}) 
1761   
1762   
1763 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1764          'Writes this packet to the supplied buffer' 
1765          self._bufferstartoffset=buf.getcurrentoffset() 
1766          self.__field_numactiveitems.writetobuffer(buf) 
1767          try: self.__field_items 
1768          except: 
1769              self.__field_items=LIST(**{'length': self.maxitems, 'elementclass': indexentry, 'createdefault': True}) 
1770          self.__field_items.writetobuffer(buf) 
1771          self._bufferendoffset=buf.getcurrentoffset() 
1772          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1773   
1774   
1775 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1776          'Reads this packet from the supplied buffer' 
1777          self._bufferstartoffset=buf.getcurrentoffset() 
1778          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1779          self.__field_numactiveitems=UINT(**{'sizeinbytes': 2}) 
1780          self.__field_numactiveitems.readfrombuffer(buf) 
1781          self.__field_items=LIST(**{'length': self.maxitems, 'elementclass': indexentry, 'createdefault': True}) 
1782          self.__field_items.readfrombuffer(buf) 
1783          self._bufferendoffset=buf.getcurrentoffset() 
1784   
1785   
1786 -    def __getfield_maxitems(self): 
1787          return self.__field_maxitems.getvalue() 
1788   
1789 -    def __setfield_maxitems(self, value): 
1790          if isinstance(value,UINT): 
1791              self.__field_maxitems=value 
1792          else: 
1793              self.__field_maxitems=UINT(value,**{'constant': 30}) 
1794   
1795 -    def __delfield_maxitems(self): del self.__field_maxitems 
1796   
1797      maxitems=property(__getfield_maxitems, __setfield_maxitems, __delfield_maxitems, None) 
1798   
1799 -    def __getfield_numactiveitems(self): 
1800          return self.__field_numactiveitems.getvalue() 
1801   
1802 -    def __setfield_numactiveitems(self, value): 
1803          if isinstance(value,UINT): 
1804              self.__field_numactiveitems=value 
1805          else: 
1806              self.__field_numactiveitems=UINT(value,**{'sizeinbytes': 2}) 
1807   
1808 -    def __delfield_numactiveitems(self): del self.__field_numactiveitems 
1809   
1810      numactiveitems=property(__getfield_numactiveitems, __setfield_numactiveitems, __delfield_numactiveitems, None) 
1811   
1812 -    def __getfield_items(self): 
1813          try: self.__field_items 
1814          except: 
1815              self.__field_items=LIST(**{'length': self.maxitems, 'elementclass': indexentry, 'createdefault': True}) 
1816          return self.__field_items.getvalue() 
1817   
1818 -    def __setfield_items(self, value): 
1819          if isinstance(value,LIST): 
1820              self.__field_items=value 
1821          else: 
1822              self.__field_items=LIST(value,**{'length': self.maxitems, 'elementclass': indexentry, 'createdefault': True}) 
1823   
1824 -    def __delfield_items(self): del self.__field_items 
1825   
1826      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
1827   
1828 -    def iscontainer(self): 
1829          return True 
1830   
1831 -    def containerelements(self): 
1832          yield ('maxitems', self.__field_maxitems, None) 
1833          yield ('numactiveitems', self.__field_numactiveitems, None) 
1834          yield ('items', self.__field_items, None) 
1835   
1836   
1837   
1838   
1839 -class camindexentry(BaseProtogenClass): 
1840      __fields=['index', 'unknown1', 'name', 'taken', 'unkown2'] 
1841   
1842 -    def __init__(self, *args, **kwargs): 
1843          dict={} 
1844          # What was supplied to this function 
1845          dict.update(kwargs) 
1846          # Parent constructor 
1847          super(camindexentry,self).__init__(**dict) 
1848          if self.__class__ is camindexentry: 
1849              self._update(args,dict) 
1850   
1851   
1852 -    def getfields(self): 
1853          return self.__fields 
1854   
1855   
1856 -    def _update(self, args, kwargs): 
1857          super(camindexentry,self)._update(args,kwargs) 
1858          keys=kwargs.keys() 
1859          for key in keys: 
1860              if key in self.__fields: 
1861                  setattr(self, key, kwargs[key]) 
1862                  del kwargs[key] 
1863          # Were any unrecognized kwargs passed in? 
1864          if __debug__: 
1865              self._complainaboutunusedargs(camindexentry,kwargs) 
1866          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1867          # Make all P fields that haven't already been constructed 
1868   
1869   
1870 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1871          'Writes this packet to the supplied buffer' 
1872          self._bufferstartoffset=buf.getcurrentoffset() 
1873          self.__field_index.writetobuffer(buf) 
1874          try: self.__field_unknown1 
1875          except: 
1876              self.__field_unknown1=UINT(**{'sizeinbytes': 1, 'default' : 80}) 
1877          self.__field_unknown1.writetobuffer(buf) 
1878          try: self.__field_name 
1879          except: 
1880              self.__field_name=USTRING(**{'sizeinbytes': 10, 'default': ""}) 
1881          self.__field_name.writetobuffer(buf) 
1882          self.__field_taken.writetobuffer(buf) 
1883          self.__field_unkown2.writetobuffer(buf) 
1884          self._bufferendoffset=buf.getcurrentoffset() 
1885          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1886   
1887   
1888 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1889          'Reads this packet from the supplied buffer' 
1890          self._bufferstartoffset=buf.getcurrentoffset() 
1891          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1892          self.__field_index=UINT(**{'sizeinbytes': 1}) 
1893          self.__field_index.readfrombuffer(buf) 
1894          self.__field_unknown1=UINT(**{'sizeinbytes': 1, 'default' : 80}) 
1895          self.__field_unknown1.readfrombuffer(buf) 
1896          self.__field_name=USTRING(**{'sizeinbytes': 10, 'default': ""}) 
1897          self.__field_name.readfrombuffer(buf) 
1898          self.__field_taken=LGCALDATE(**{'sizeinbytes': 4}) 
1899          self.__field_taken.readfrombuffer(buf) 
1900          self.__field_unkown2=UINT(**{'sizeinbytes': 4}) 
1901          self.__field_unkown2.readfrombuffer(buf) 
1902          self._bufferendoffset=buf.getcurrentoffset() 
1903   
1904   
1905 -    def __getfield_index(self): 
1906          return self.__field_index.getvalue() 
1907   
1908 -    def __setfield_index(self, value): 
1909          if isinstance(value,UINT): 
1910              self.__field_index=value 
1911          else: 
1912              self.__field_index=UINT(value,**{'sizeinbytes': 1}) 
1913   
1914 -    def __delfield_index(self): del self.__field_index 
1915   
1916      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
1917   
1918 -    def __getfield_unknown1(self): 
1919          try: self.__field_unknown1 
1920          except: 
1921              self.__field_unknown1=UINT(**{'sizeinbytes': 1, 'default' : 80}) 
1922          return self.__field_unknown1.getvalue() 
1923   
1924 -    def __setfield_unknown1(self, value): 
1925          if isinstance(value,UINT): 
1926              self.__field_unknown1=value 
1927          else: 
1928              self.__field_unknown1=UINT(value,**{'sizeinbytes': 1, 'default' : 80}) 
1929   
1930 -    def __delfield_unknown1(self): del self.__field_unknown1 
1931   
1932      unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 
1933   
1934 -    def __getfield_name(self): 
1935          try: self.__field_name 
1936          except: 
1937              self.__field_name=USTRING(**{'sizeinbytes': 10, 'default': ""}) 
1938          return self.__field_name.getvalue() 
1939   
1940 -    def __setfield_name(self, value): 
1941          if isinstance(value,USTRING): 
1942              self.__field_name=value 
1943          else: 
1944              self.__field_name=USTRING(value,**{'sizeinbytes': 10, 'default': ""}) 
1945   
1946 -    def __delfield_name(self): del self.__field_name 
1947   
1948      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
1949   
1950 -    def __getfield_taken(self): 
1951          return self.__field_taken.getvalue() 
1952   
1953 -    def __setfield_taken(self, value): 
1954          if isinstance(value,LGCALDATE): 
1955              self.__field_taken=value 
1956          else: 
1957              self.__field_taken=LGCALDATE(value,**{'sizeinbytes': 4}) 
1958   
1959 -    def __delfield_taken(self): del self.__field_taken 
1960   
1961      taken=property(__getfield_taken, __setfield_taken, __delfield_taken, None) 
1962   
1963 -    def __getfield_unkown2(self): 
1964          return self.__field_unkown2.getvalue() 
1965   
1966 -    def __setfield_unkown2(self, value): 
1967          if isinstance(value,UINT): 
1968              self.__field_unkown2=value 
1969          else: 
1970              self.__field_unkown2=UINT(value,**{'sizeinbytes': 4}) 
1971   
1972 -    def __delfield_unkown2(self): del self.__field_unkown2 
1973   
1974      unkown2=property(__getfield_unkown2, __setfield_unkown2, __delfield_unkown2, None) 
1975   
1976 -    def iscontainer(self): 
1977          return True 
1978   
1979 -    def containerelements(self): 
1980          yield ('index', self.__field_index, None) 
1981          yield ('unknown1', self.__field_unknown1, None) 
1982          yield ('name', self.__field_name, None) 
1983          yield ('taken', self.__field_taken, None) 
1984          yield ('unkown2', self.__field_unkown2, None) 
1985   
1986   
1987   
1988   
1989 -class camindexfile(BaseProtogenClass): 
1990      "Used for tracking wallpaper and ringtones" 
1991      __fields=['maxitems', 'items'] 
1992   
1993 -    def __init__(self, *args, **kwargs): 
1994          dict={} 
1995          # What was supplied to this function 
1996          dict.update(kwargs) 
1997          # Parent constructor 
1998          super(camindexfile,self).__init__(**dict) 
1999          if self.__class__ is camindexfile: 
2000              self._update(args,dict) 
2001   
2002   
2003 -    def getfields(self): 
2004          return self.__fields 
2005   
2006   
2007 -    def _update(self, args, kwargs): 
2008          super(camindexfile,self)._update(args,kwargs) 
2009          keys=kwargs.keys() 
2010          for key in keys: 
2011              if key in self.__fields: 
2012                  setattr(self, key, kwargs[key]) 
2013                  del kwargs[key] 
2014          # Were any unrecognized kwargs passed in? 
2015          if __debug__: 
2016              self._complainaboutunusedargs(camindexfile,kwargs) 
2017          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2018          # Make all P fields that haven't already been constructed 
2019          try: self.__field_maxitems 
2020          except: 
2021              self.__field_maxitems=UINT(**{'constant': 60}) 
2022   
2023   
2024 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2025          'Writes this packet to the supplied buffer' 
2026          self._bufferstartoffset=buf.getcurrentoffset() 
2027          try: self.__field_items 
2028          except: 
2029              self.__field_items=LIST(**{'length': self.maxitems, 'elementclass': camindexentry, 'createdefault': True}) 
2030          self.__field_items.writetobuffer(buf) 
2031          self._bufferendoffset=buf.getcurrentoffset() 
2032          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2033   
2034   
2035 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2036          'Reads this packet from the supplied buffer' 
2037          self._bufferstartoffset=buf.getcurrentoffset() 
2038          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2039          self.__field_items=LIST(**{'length': self.maxitems, 'elementclass': camindexentry, 'createdefault': True}) 
2040          self.__field_items.readfrombuffer(buf) 
2041          self._bufferendoffset=buf.getcurrentoffset() 
2042   
2043   
2044 -    def __getfield_maxitems(self): 
2045          return self.__field_maxitems.getvalue() 
2046   
2047 -    def __setfield_maxitems(self, value): 
2048          if isinstance(value,UINT): 
2049              self.__field_maxitems=value 
2050          else: 
2051              self.__field_maxitems=UINT(value,**{'constant': 60}) 
2052   
2053 -    def __delfield_maxitems(self): del self.__field_maxitems 
2054   
2055      maxitems=property(__getfield_maxitems, __setfield_maxitems, __delfield_maxitems, None) 
2056   
2057 -    def __getfield_items(self): 
2058          try: self.__field_items 
2059          except: 
2060              self.__field_items=LIST(**{'length': self.maxitems, 'elementclass': camindexentry, 'createdefault': True}) 
2061          return self.__field_items.getvalue() 
2062   
2063 -    def __setfield_items(self, value): 
2064          if isinstance(value,LIST): 
2065              self.__field_items=value 
2066          else: 
2067              self.__field_items=LIST(value,**{'length': self.maxitems, 'elementclass': camindexentry, 'createdefault': True}) 
2068   
2069 -    def __delfield_items(self): del self.__field_items 
2070   
2071      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
2072   
2073 -    def iscontainer(self): 
2074          return True 
2075   
2076 -    def containerelements(self): 
2077          yield ('maxitems', self.__field_maxitems, None) 
2078          yield ('items', self.__field_items, None) 
2079   
2080   
2081   
2082   
2083 -class mediadesc(BaseProtogenClass): 
2084      __fields=['totalsize', 'dunno1', 'magic1', 'magic2', 'magic3', 'dunno2', 'filename', 'whoknows', 'mimetype', 'whoknows2'] 
2085   
2086 -    def __init__(self, *args, **kwargs): 
2087          dict={} 
2088          # What was supplied to this function 
2089          dict.update(kwargs) 
2090          # Parent constructor 
2091          super(mediadesc,self).__init__(**dict) 
2092          if self.__class__ is mediadesc: 
2093              self._update(args,dict) 
2094   
2095   
2096 -    def getfields(self): 
2097          return self.__fields 
2098   
2099   
2100 -    def _update(self, args, kwargs): 
2101          super(mediadesc,self)._update(args,kwargs) 
2102          keys=kwargs.keys() 
2103          for key in keys: 
2104              if key in self.__fields: 
2105                  setattr(self, key, kwargs[key]) 
2106                  del kwargs[key] 
2107          # Were any unrecognized kwargs passed in? 
2108          if __debug__: 
2109              self._complainaboutunusedargs(mediadesc,kwargs) 
2110          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2111          # Make all P fields that haven't already been constructed 
2112   
2113   
2114 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2115          'Writes this packet to the supplied buffer' 
2116          self._bufferstartoffset=buf.getcurrentoffset() 
2117          self.__field_totalsize.writetobuffer(buf) 
2118          try: self.__field_dunno1 
2119          except: 
2120              self.__field_dunno1=UINT(**{'sizeinbytes': 4, 'constant': 0}) 
2121          self.__field_dunno1.writetobuffer(buf) 
2122          try: self.__field_magic1 
2123          except: 
2124              self.__field_magic1=UINT(**{'sizeinbytes': 4, 'default': 0x7824c97a}) 
2125          self.__field_magic1.writetobuffer(buf) 
2126          try: self.__field_magic2 
2127          except: 
2128              self.__field_magic2=UINT(**{'sizeinbytes': 4, 'default': 0x7824c97a}) 
2129          self.__field_magic2.writetobuffer(buf) 
2130          try: self.__field_magic3 
2131          except: 
2132              self.__field_magic3=UINT(**{'sizeinbytes': 4, 'default': 0x7824c97a}) 
2133          self.__field_magic3.writetobuffer(buf) 
2134          try: self.__field_dunno2 
2135          except: 
2136              self.__field_dunno2=UINT(**{'sizeinbytes': 4, 'constant': 0}) 
2137          self.__field_dunno2.writetobuffer(buf) 
2138          try: self.__field_filename 
2139          except: 
2140              self.__field_filename=USTRING(**{'sizeinbytes': 32, 'default': 'body'}) 
2141          self.__field_filename.writetobuffer(buf) 
2142          try: self.__field_whoknows 
2143          except: 
2144              self.__field_whoknows=USTRING(**{'sizeinbytes': 32, 'default': 'identity'}) 
2145          self.__field_whoknows.writetobuffer(buf) 
2146          self.__field_mimetype.writetobuffer(buf) 
2147          try: self.__field_whoknows2 
2148          except: 
2149              self.__field_whoknows2=USTRING(**{'sizeinbytes': 32, 'default': ""}) 
2150          self.__field_whoknows2.writetobuffer(buf) 
2151          self._bufferendoffset=buf.getcurrentoffset() 
2152          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2153   
2154   
2155 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2156          'Reads this packet from the supplied buffer' 
2157          self._bufferstartoffset=buf.getcurrentoffset() 
2158          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2159          self.__field_totalsize=UINT(**{'sizeinbytes': 4}) 
2160          self.__field_totalsize.readfrombuffer(buf) 
2161          self.__field_dunno1=UINT(**{'sizeinbytes': 4, 'constant': 0}) 
2162          self.__field_dunno1.readfrombuffer(buf) 
2163          self.__field_magic1=UINT(**{'sizeinbytes': 4, 'default': 0x7824c97a}) 
2164          self.__field_magic1.readfrombuffer(buf) 
2165          self.__field_magic2=UINT(**{'sizeinbytes': 4, 'default': 0x7824c97a}) 
2166          self.__field_magic2.readfrombuffer(buf) 
2167          self.__field_magic3=UINT(**{'sizeinbytes': 4, 'default': 0x7824c97a}) 
2168          self.__field_magic3.readfrombuffer(buf) 
2169          self.__field_dunno2=UINT(**{'sizeinbytes': 4, 'constant': 0}) 
2170          self.__field_dunno2.readfrombuffer(buf) 
2171          self.__field_filename=USTRING(**{'sizeinbytes': 32, 'default': 'body'}) 
2172          self.__field_filename.readfrombuffer(buf) 
2173          self.__field_whoknows=USTRING(**{'sizeinbytes': 32, 'default': 'identity'}) 
2174          self.__field_whoknows.readfrombuffer(buf) 
2175          self.__field_mimetype=USTRING(**{'sizeinbytes': 32}) 
2176          self.__field_mimetype.readfrombuffer(buf) 
2177          self.__field_whoknows2=USTRING(**{'sizeinbytes': 32, 'default': ""}) 
2178          self.__field_whoknows2.readfrombuffer(buf) 
2179          self._bufferendoffset=buf.getcurrentoffset() 
2180   
2181   
2182 -    def __getfield_totalsize(self): 
2183          return self.__field_totalsize.getvalue() 
2184   
2185 -    def __setfield_totalsize(self, value): 
2186          if isinstance(value,UINT): 
2187              self.__field_totalsize=value 
2188          else: 
2189              self.__field_totalsize=UINT(value,**{'sizeinbytes': 4}) 
2190   
2191 -    def __delfield_totalsize(self): del self.__field_totalsize 
2192   
2193      totalsize=property(__getfield_totalsize, __setfield_totalsize, __delfield_totalsize, "media file size with size of this file (152 bytes) added") 
2194   
2195 -    def __getfield_dunno1(self): 
2196          try: self.__field_dunno1 
2197          except: 
2198              self.__field_dunno1=UINT(**{'sizeinbytes': 4, 'constant': 0}) 
2199          return self.__field_dunno1.getvalue() 
2200   
2201 -    def __setfield_dunno1(self, value): 
2202          if isinstance(value,UINT): 
2203              self.__field_dunno1=value 
2204          else: 
2205              self.__field_dunno1=UINT(value,**{'sizeinbytes': 4, 'constant': 0}) 
2206   
2207 -    def __delfield_dunno1(self): del self.__field_dunno1 
2208   
2209      dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None) 
2210   
2211 -    def __getfield_magic1(self): 
2212          try: self.__field_magic1 
2213          except: 
2214              self.__field_magic1=UINT(**{'sizeinbytes': 4, 'default': 0x7824c97a}) 
2215          return self.__field_magic1.getvalue() 
2216   
2217 -    def __setfield_magic1(self, value): 
2218          if isinstance(value,UINT): 
2219              self.__field_magic1=value 
2220          else: 
2221              self.__field_magic1=UINT(value,**{'sizeinbytes': 4, 'default': 0x7824c97a}) 
2222   
2223 -    def __delfield_magic1(self): del self.__field_magic1 
2224   
2225      magic1=property(__getfield_magic1, __setfield_magic1, __delfield_magic1, "probably the file date (created)") 
2226   
2227 -    def __getfield_magic2(self): 
2228          try: self.__field_magic2 
2229          except: 
2230              self.__field_magic2=UINT(**{'sizeinbytes': 4, 'default': 0x7824c97a}) 
2231          return self.__field_magic2.getvalue() 
2232   
2233 -    def __setfield_magic2(self, value): 
2234          if isinstance(value,UINT): 
2235              self.__field_magic2=value 
2236          else: 
2237              self.__field_magic2=UINT(value,**{'sizeinbytes': 4, 'default': 0x7824c97a}) 
2238   
2239 -    def __delfield_magic2(self): del self.__field_magic2 
2240   
2241      magic2=property(__getfield_magic2, __setfield_magic2, __delfield_magic2, "probably the file date (accessed)") 
2242   
2243 -    def __getfield_magic3(self): 
2244          try: self.__field_magic3 
2245          except: 
2246              self.__field_magic3=UINT(**{'sizeinbytes': 4, 'default': 0x7824c97a}) 
2247          return self.__field_magic3.getvalue() 
2248   
2249 -    def __setfield_magic3(self, value): 
2250          if isinstance(value,UINT): 
2251              self.__field_magic3=value 
2252          else: 
2253              self.__field_magic3=UINT(value,**{'sizeinbytes': 4, 'default': 0x7824c97a}) 
2254   
2255 -    def __delfield_magic3(self): del self.__field_magic3 
2256   
2257      magic3=property(__getfield_magic3, __setfield_magic3, __delfield_magic3, "probably the file date (modified)") 
2258   
2259 -    def __getfield_dunno2(self): 
2260          try: self.__field_dunno2 
2261          except: 
2262              self.__field_dunno2=UINT(**{'sizeinbytes': 4, 'constant': 0}) 
2263          return self.__field_dunno2.getvalue() 
2264   
2265 -    def __setfield_dunno2(self, value): 
2266          if isinstance(value,UINT): 
2267              self.__field_dunno2=value 
2268          else: 
2269              self.__field_dunno2=UINT(value,**{'sizeinbytes': 4, 'constant': 0}) 
2270   
2271 -    def __delfield_dunno2(self): del self.__field_dunno2 
2272   
2273      dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None) 
2274   
2275 -    def __getfield_filename(self): 
2276          try: self.__field_filename 
2277          except: 
2278              self.__field_filename=USTRING(**{'sizeinbytes': 32, 'default': 'body'}) 
2279          return self.__field_filename.getvalue() 
2280   
2281 -    def __setfield_filename(self, value): 
2282          if isinstance(value,USTRING): 
2283              self.__field_filename=value 
2284          else: 
2285              self.__field_filename=USTRING(value,**{'sizeinbytes': 32, 'default': 'body'}) 
2286   
2287 -    def __delfield_filename(self): del self.__field_filename 
2288   
2289      filename=property(__getfield_filename, __setfield_filename, __delfield_filename, None) 
2290   
2291 -    def __getfield_whoknows(self): 
2292          try: self.__field_whoknows 
2293          except: 
2294              self.__field_whoknows=USTRING(**{'sizeinbytes': 32, 'default': 'identity'}) 
2295          return self.__field_whoknows.getvalue() 
2296   
2297 -    def __setfield_whoknows(self, value): 
2298          if isinstance(value,USTRING): 
2299              self.__field_whoknows=value 
2300          else: 
2301              self.__field_whoknows=USTRING(value,**{'sizeinbytes': 32, 'default': 'identity'}) 
2302   
2303 -    def __delfield_whoknows(self): del self.__field_whoknows 
2304   
2305      whoknows=property(__getfield_whoknows, __setfield_whoknows, __delfield_whoknows, "set to iso8859_1 in some cases??") 
2306   
2307 -    def __getfield_mimetype(self): 
2308          return self.__field_mimetype.getvalue() 
2309   
2310 -    def __setfield_mimetype(self, value): 
2311          if isinstance(value,USTRING): 
2312              self.__field_mimetype=value 
2313          else: 
2314              self.__field_mimetype=USTRING(value,**{'sizeinbytes': 32}) 
2315   
2316 -    def __delfield_mimetype(self): del self.__field_mimetype 
2317   
2318      mimetype=property(__getfield_mimetype, __setfield_mimetype, __delfield_mimetype, None) 
2319   
2320 -    def __getfield_whoknows2(self): 
2321          try: self.__field_whoknows2 
2322          except: 
2323              self.__field_whoknows2=USTRING(**{'sizeinbytes': 32, 'default': ""}) 
2324          return self.__field_whoknows2.getvalue() 
2325   
2326 -    def __setfield_whoknows2(self, value): 
2327          if isinstance(value,USTRING): 
2328              self.__field_whoknows2=value 
2329          else: 
2330              self.__field_whoknows2=USTRING(value,**{'sizeinbytes': 32, 'default': ""}) 
2331   
2332 -    def __delfield_whoknows2(self): del self.__field_whoknows2 
2333   
2334      whoknows2=property(__getfield_whoknows2, __setfield_whoknows2, __delfield_whoknows2, None) 
2335   
2336 -    def iscontainer(self): 
2337          return True 
2338   
2339 -    def containerelements(self): 
2340          yield ('totalsize', self.__field_totalsize, "media file size with size of this file (152 bytes) added") 
2341          yield ('dunno1', self.__field_dunno1, None) 
2342          yield ('magic1', self.__field_magic1, "probably the file date (created)") 
2343          yield ('magic2', self.__field_magic2, "probably the file date (accessed)") 
2344          yield ('magic3', self.__field_magic3, "probably the file date (modified)") 
2345          yield ('dunno2', self.__field_dunno2, None) 
2346          yield ('filename', self.__field_filename, None) 
2347          yield ('whoknows', self.__field_whoknows, "set to iso8859_1 in some cases??") 
2348          yield ('mimetype', self.__field_mimetype, None) 
2349          yield ('whoknows2', self.__field_whoknows2, None) 
2350   
2351   
2352   
2353   
2354 -class textmemo(BaseProtogenClass): 
2355      __fields=['text'] 
2356   
2357 -    def __init__(self, *args, **kwargs): 
2358          dict={} 
2359          # What was supplied to this function 
2360          dict.update(kwargs) 
2361          # Parent constructor 
2362          super(textmemo,self).__init__(**dict) 
2363          if self.__class__ is textmemo: 
2364              self._update(args,dict) 
2365   
2366   
2367 -    def getfields(self): 
2368          return self.__fields 
2369   
2370   
2371 -    def _update(self, args, kwargs): 
2372          super(textmemo,self)._update(args,kwargs) 
2373          keys=kwargs.keys() 
2374          for key in keys: 
2375              if key in self.__fields: 
2376                  setattr(self, key, kwargs[key]) 
2377                  del kwargs[key] 
2378          # Were any unrecognized kwargs passed in? 
2379          if __debug__: 
2380              self._complainaboutunusedargs(textmemo,kwargs) 
2381          if len(args): 
2382              dict2={'sizeinbytes': 151,  'raiseonunterminatedread': False, 'raiseontruncate': False } 
2383              dict2.update(kwargs) 
2384              kwargs=dict2 
2385              self.__field_text=USTRING(*args,**dict2) 
2386          # Make all P fields that haven't already been constructed 
2387   
2388   
2389 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2390          'Writes this packet to the supplied buffer' 
2391          self._bufferstartoffset=buf.getcurrentoffset() 
2392          self.__field_text.writetobuffer(buf) 
2393          self._bufferendoffset=buf.getcurrentoffset() 
2394          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2395   
2396   
2397 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2398          'Reads this packet from the supplied buffer' 
2399          self._bufferstartoffset=buf.getcurrentoffset() 
2400          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2401          self.__field_text=USTRING(**{'sizeinbytes': 151,  'raiseonunterminatedread': False, 'raiseontruncate': False }) 
2402          self.__field_text.readfrombuffer(buf) 
2403          self._bufferendoffset=buf.getcurrentoffset() 
2404   
2405   
2406 -    def __getfield_text(self): 
2407          return self.__field_text.getvalue() 
2408   
2409 -    def __setfield_text(self, value): 
2410          if isinstance(value,USTRING): 
2411              self.__field_text=value 
2412          else: 
2413              self.__field_text=USTRING(value,**{'sizeinbytes': 151,  'raiseonunterminatedread': False, 'raiseontruncate': False }) 
2414   
2415 -    def __delfield_text(self): del self.__field_text 
2416   
2417      text=property(__getfield_text, __setfield_text, __delfield_text, None) 
2418   
2419 -    def iscontainer(self): 
2420          return True 
2421   
2422 -    def containerelements(self): 
2423          yield ('text', self.__field_text, None) 
2424   
2425   
2426   
2427   
2428 -class textmemofile(BaseProtogenClass): 
2429      __fields=['itemcount', 'items'] 
2430   
2431 -    def __init__(self, *args, **kwargs): 
2432          dict={} 
2433          # What was supplied to this function 
2434          dict.update(kwargs) 
2435          # Parent constructor 
2436          super(textmemofile,self).__init__(**dict) 
2437          if self.__class__ is textmemofile: 
2438              self._update(args,dict) 
2439   
2440   
2441 -    def getfields(self): 
2442          return self.__fields 
2443   
2444   
2445 -    def _update(self, args, kwargs): 
2446          super(textmemofile,self)._update(args,kwargs) 
2447          keys=kwargs.keys() 
2448          for key in keys: 
2449              if key in self.__fields: 
2450                  setattr(self, key, kwargs[key]) 
2451                  del kwargs[key] 
2452          # Were any unrecognized kwargs passed in? 
2453          if __debug__: 
2454              self._complainaboutunusedargs(textmemofile,kwargs) 
2455          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2456          # Make all P fields that haven't already been constructed 
2457   
2458   
2459 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2460          'Writes this packet to the supplied buffer' 
2461          self._bufferstartoffset=buf.getcurrentoffset() 
2462          self.__field_itemcount.writetobuffer(buf) 
2463          try: self.__field_items 
2464          except: 
2465              self.__field_items=LIST(**{'elementclass': textmemo }) 
2466          self.__field_items.writetobuffer(buf) 
2467          self._bufferendoffset=buf.getcurrentoffset() 
2468          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2469   
2470   
2471 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2472          'Reads this packet from the supplied buffer' 
2473          self._bufferstartoffset=buf.getcurrentoffset() 
2474          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2475          self.__field_itemcount=UINT(**{'sizeinbytes': 4}) 
2476          self.__field_itemcount.readfrombuffer(buf) 
2477          self.__field_items=LIST(**{'elementclass': textmemo }) 
2478          self.__field_items.readfrombuffer(buf) 
2479          self._bufferendoffset=buf.getcurrentoffset() 
2480   
2481   
2482 -    def __getfield_itemcount(self): 
2483          return self.__field_itemcount.getvalue() 
2484   
2485 -    def __setfield_itemcount(self, value): 
2486          if isinstance(value,UINT): 
2487              self.__field_itemcount=value 
2488          else: 
2489              self.__field_itemcount=UINT(value,**{'sizeinbytes': 4}) 
2490   
2491 -    def __delfield_itemcount(self): del self.__field_itemcount 
2492   
2493      itemcount=property(__getfield_itemcount, __setfield_itemcount, __delfield_itemcount, None) 
2494   
2495 -    def __getfield_items(self): 
2496          try: self.__field_items 
2497          except: 
2498              self.__field_items=LIST(**{'elementclass': textmemo }) 
2499          return self.__field_items.getvalue() 
2500   
2501 -    def __setfield_items(self, value): 
2502          if isinstance(value,LIST): 
2503              self.__field_items=value 
2504          else: 
2505              self.__field_items=LIST(value,**{'elementclass': textmemo }) 
2506   
2507 -    def __delfield_items(self): del self.__field_items 
2508   
2509      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
2510   
2511 -    def iscontainer(self): 
2512          return True 
2513   
2514 -    def containerelements(self): 
2515          yield ('itemcount', self.__field_itemcount, None) 
2516          yield ('items', self.__field_items, None) 
2517   
2518   
2519   
2520   
2521 -class scheduleexception(BaseProtogenClass): 
2522      __fields=['pos', 'day', 'month', 'year'] 
2523   
2524 -    def __init__(self, *args, **kwargs): 
2525          dict={} 
2526          # What was supplied to this function 
2527          dict.update(kwargs) 
2528          # Parent constructor 
2529          super(scheduleexception,self).__init__(**dict) 
2530          if self.__class__ is scheduleexception: 
2531              self._update(args,dict) 
2532   
2533   
2534 -    def getfields(self): 
2535          return self.__fields 
2536   
2537   
2538 -    def _update(self, args, kwargs): 
2539          super(scheduleexception,self)._update(args,kwargs) 
2540          keys=kwargs.keys() 
2541          for key in keys: 
2542              if key in self.__fields: 
2543                  setattr(self, key, kwargs[key]) 
2544                  del kwargs[key] 
2545          # Were any unrecognized kwargs passed in? 
2546          if __debug__: 
2547              self._complainaboutunusedargs(scheduleexception,kwargs) 
2548          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2549          # Make all P fields that haven't already been constructed 
2550   
2551   
2552 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2553          'Writes this packet to the supplied buffer' 
2554          self._bufferstartoffset=buf.getcurrentoffset() 
2555          self.__field_pos.writetobuffer(buf) 
2556          self.__field_day.writetobuffer(buf) 
2557          self.__field_month.writetobuffer(buf) 
2558          self.__field_year.writetobuffer(buf) 
2559          self._bufferendoffset=buf.getcurrentoffset() 
2560          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2561   
2562   
2563 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2564          'Reads this packet from the supplied buffer' 
2565          self._bufferstartoffset=buf.getcurrentoffset() 
2566          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2567          self.__field_pos=UINT(**{'sizeinbytes': 4}) 
2568          self.__field_pos.readfrombuffer(buf) 
2569          self.__field_day=UINT(**{'sizeinbytes': 1}) 
2570          self.__field_day.readfrombuffer(buf) 
2571          self.__field_month=UINT(**{'sizeinbytes': 1}) 
2572          self.__field_month.readfrombuffer(buf) 
2573          self.__field_year=UINT(**{'sizeinbytes': 2}) 
2574          self.__field_year.readfrombuffer(buf) 
2575          self._bufferendoffset=buf.getcurrentoffset() 
2576   
2577   
2578 -    def __getfield_pos(self): 
2579          return self.__field_pos.getvalue() 
2580   
2581 -    def __setfield_pos(self, value): 
2582          if isinstance(value,UINT): 
2583              self.__field_pos=value 
2584          else: 
2585              self.__field_pos=UINT(value,**{'sizeinbytes': 4}) 
2586   
2587 -    def __delfield_pos(self): del self.__field_pos 
2588   
2589      pos=property(__getfield_pos, __setfield_pos, __delfield_pos, "Refers to event id (position in schedule file) that this suppresses") 
2590   
2591 -    def __getfield_day(self): 
2592          return self.__field_day.getvalue() 
2593   
2594 -    def __setfield_day(self, value): 
2595          if isinstance(value,UINT): 
2596              self.__field_day=value 
2597          else: 
2598              self.__field_day=UINT(value,**{'sizeinbytes': 1}) 
2599   
2600 -    def __delfield_day(self): del self.__field_day 
2601   
2602      day=property(__getfield_day, __setfield_day, __delfield_day, None) 
2603   
2604 -    def __getfield_month(self): 
2605          return self.__field_month.getvalue() 
2606   
2607 -    def __setfield_month(self, value): 
2608          if isinstance(value,UINT): 
2609              self.__field_month=value 
2610          else: 
2611              self.__field_month=UINT(value,**{'sizeinbytes': 1}) 
2612   
2613 -    def __delfield_month(self): del self.__field_month 
2614   
2615      month=property(__getfield_month, __setfield_month, __delfield_month, None) 
2616   
2617 -    def __getfield_year(self): 
2618          return self.__field_year.getvalue() 
2619   
2620 -    def __setfield_year(self, value): 
2621          if isinstance(value,UINT): 
2622              self.__field_year=value 
2623          else: 
2624              self.__field_year=UINT(value,**{'sizeinbytes': 2}) 
2625   
2626 -    def __delfield_year(self): del self.__field_year 
2627   
2628      year=property(__getfield_year, __setfield_year, __delfield_year, None) 
2629   
2630 -    def iscontainer(self): 
2631          return True 
2632   
2633 -    def containerelements(self): 
2634          yield ('pos', self.__field_pos, "Refers to event id (position in schedule file) that this suppresses") 
2635          yield ('day', self.__field_day, None) 
2636          yield ('month', self.__field_month, None) 
2637          yield ('year', self.__field_year, None) 
2638   
2639   
2640   
2641   
2642 -class scheduleexceptionfile(BaseProtogenClass): 
2643      __fields=['items'] 
2644   
2645 -    def __init__(self, *args, **kwargs): 
2646          dict={} 
2647          # What was supplied to this function 
2648          dict.update(kwargs) 
2649          # Parent constructor 
2650          super(scheduleexceptionfile,self).__init__(**dict) 
2651          if self.__class__ is scheduleexceptionfile: 
2652              self._update(args,dict) 
2653   
2654   
2655 -    def getfields(self): 
2656          return self.__fields 
2657   
2658   
2659 -    def _update(self, args, kwargs): 
2660          super(scheduleexceptionfile,self)._update(args,kwargs) 
2661          keys=kwargs.keys() 
2662          for key in keys: 
2663              if key in self.__fields: 
2664                  setattr(self, key, kwargs[key]) 
2665                  del kwargs[key] 
2666          # Were any unrecognized kwargs passed in? 
2667          if __debug__: 
2668              self._complainaboutunusedargs(scheduleexceptionfile,kwargs) 
2669          if len(args): 
2670              dict2={'elementclass': scheduleexception} 
2671              dict2.update(kwargs) 
2672              kwargs=dict2 
2673              self.__field_items=LIST(*args,**dict2) 
2674          # Make all P fields that haven't already been constructed 
2675   
2676   
2677 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2678          'Writes this packet to the supplied buffer' 
2679          self._bufferstartoffset=buf.getcurrentoffset() 
2680          try: self.__field_items 
2681          except: 
2682              self.__field_items=LIST(**{'elementclass': scheduleexception}) 
2683          self.__field_items.writetobuffer(buf) 
2684          self._bufferendoffset=buf.getcurrentoffset() 
2685          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2686   
2687   
2688 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2689          'Reads this packet from the supplied buffer' 
2690          self._bufferstartoffset=buf.getcurrentoffset() 
2691          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2692          self.__field_items=LIST(**{'elementclass': scheduleexception}) 
2693          self.__field_items.readfrombuffer(buf) 
2694          self._bufferendoffset=buf.getcurrentoffset() 
2695   
2696   
2697 -    def __getfield_items(self): 
2698          try: self.__field_items 
2699          except: 
2700              self.__field_items=LIST(**{'elementclass': scheduleexception}) 
2701          return self.__field_items.getvalue() 
2702   
2703 -    def __setfield_items(self, value): 
2704          if isinstance(value,LIST): 
2705              self.__field_items=value 
2706          else: 
2707              self.__field_items=LIST(value,**{'elementclass': scheduleexception}) 
2708   
2709 -    def __delfield_items(self): del self.__field_items 
2710   
2711      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
2712   
2713 -    def iscontainer(self): 
2714          return True 
2715   
2716 -    def containerelements(self): 
2717          yield ('items', self.__field_items, None) 
2718   
2719   
2720   
2721   
2722 -class scheduleevent(BaseProtogenClass): 
2723      __fields=['packet_size', 'pos', 'start', 'end', 'repeat', 'daybitmap', 'pad2', 'alarmminutes', 'alarmhours', 'alarmtype', 'snoozedelay', 'ringtone', 'description', 'unknown1', 'hasvoice', 'voiceid', 'unknown2'] 
2724   
2725 -    def __init__(self, *args, **kwargs): 
2726          dict={} 
2727          # What was supplied to this function 
2728          dict.update(kwargs) 
2729          # Parent constructor 
2730          super(scheduleevent,self).__init__(**dict) 
2731          if self.__class__ is scheduleevent: 
2732              self._update(args,dict) 
2733   
2734   
2735 -    def getfields(self): 
2736          return self.__fields 
2737   
2738   
2739 -    def _update(self, args, kwargs): 
2740          super(scheduleevent,self)._update(args,kwargs) 
2741          keys=kwargs.keys() 
2742          for key in keys: 
2743              if key in self.__fields: 
2744                  setattr(self, key, kwargs[key]) 
2745                  del kwargs[key] 
2746          # Were any unrecognized kwargs passed in? 
2747          if __debug__: 
2748              self._complainaboutunusedargs(scheduleevent,kwargs) 
2749          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2750          # Make all P fields that haven't already been constructed 
2751          try: self.__field_packet_size 
2752          except: 
2753              self.__field_packet_size=UINT(**{ 'constant': 64 }) 
2754   
2755   
2756 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2757          'Writes this packet to the supplied buffer' 
2758          self._bufferstartoffset=buf.getcurrentoffset() 
2759          self.__field_pos.writetobuffer(buf) 
2760          self.__field_start.writetobuffer(buf) 
2761          self.__field_end.writetobuffer(buf) 
2762          self.__field_repeat.writetobuffer(buf) 
2763          self.__field_daybitmap.writetobuffer(buf) 
2764          try: self.__field_pad2 
2765          except: 
2766              self.__field_pad2=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
2767          self.__field_pad2.writetobuffer(buf) 
2768          self.__field_alarmminutes.writetobuffer(buf) 
2769          self.__field_alarmhours.writetobuffer(buf) 
2770          self.__field_alarmtype.writetobuffer(buf) 
2771          try: self.__field_snoozedelay 
2772          except: 
2773              self.__field_snoozedelay=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
2774          self.__field_snoozedelay.writetobuffer(buf) 
2775          self.__field_ringtone.writetobuffer(buf) 
2776          self.__field_description.writetobuffer(buf) 
2777          try: self.__field_unknown1 
2778          except: 
2779              self.__field_unknown1=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
2780          self.__field_unknown1.writetobuffer(buf) 
2781          self.__field_hasvoice.writetobuffer(buf) 
2782          self.__field_voiceid.writetobuffer(buf) 
2783          try: self.__field_unknown2 
2784          except: 
2785              self.__field_unknown2=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
2786          self.__field_unknown2.writetobuffer(buf) 
2787          self._bufferendoffset=buf.getcurrentoffset() 
2788          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2789   
2790   
2791 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2792          'Reads this packet from the supplied buffer' 
2793          self._bufferstartoffset=buf.getcurrentoffset() 
2794          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2795          self.__field_pos=UINT(**{'sizeinbytes': 4}) 
2796          self.__field_pos.readfrombuffer(buf) 
2797          self.__field_start=LGCALDATE(**{'sizeinbytes': 4}) 
2798          self.__field_start.readfrombuffer(buf) 
2799          self.__field_end=LGCALDATE(**{'sizeinbytes': 4}) 
2800          self.__field_end.readfrombuffer(buf) 
2801          self.__field_repeat=UINT(**{'sizeinbytes': 1}) 
2802          self.__field_repeat.readfrombuffer(buf) 
2803          self.__field_daybitmap=UINT(**{'sizeinbytes': 2}) 
2804          self.__field_daybitmap.readfrombuffer(buf) 
2805          self.__field_pad2=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
2806          self.__field_pad2.readfrombuffer(buf) 
2807          self.__field_alarmminutes=UINT(**{'sizeinbytes': 1}) 
2808          self.__field_alarmminutes.readfrombuffer(buf) 
2809          self.__field_alarmhours=UINT(**{'sizeinbytes': 1}) 
2810          self.__field_alarmhours.readfrombuffer(buf) 
2811          self.__field_alarmtype=UINT(**{'sizeinbytes': 1}) 
2812          self.__field_alarmtype.readfrombuffer(buf) 
2813          self.__field_snoozedelay=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
2814          self.__field_snoozedelay.readfrombuffer(buf) 
2815          self.__field_ringtone=UINT(**{'sizeinbytes': 1}) 
2816          self.__field_ringtone.readfrombuffer(buf) 
2817          self.__field_description=USTRING(**{'sizeinbytes': 35, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False }) 
2818          self.__field_description.readfrombuffer(buf) 
2819          self.__field_unknown1=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
2820          self.__field_unknown1.readfrombuffer(buf) 
2821          self.__field_hasvoice=UINT(**{'sizeinbytes': 2}) 
2822          self.__field_hasvoice.readfrombuffer(buf) 
2823          self.__field_voiceid=UINT(**{'sizeinbytes': 2}) 
2824          self.__field_voiceid.readfrombuffer(buf) 
2825          self.__field_unknown2=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
2826          self.__field_unknown2.readfrombuffer(buf) 
2827          self._bufferendoffset=buf.getcurrentoffset() 
2828   
2829   
2830 -    def __getfield_packet_size(self): 
2831          return self.__field_packet_size.getvalue() 
2832   
2833 -    def __setfield_packet_size(self, value): 
2834          if isinstance(value,UINT): 
2835              self.__field_packet_size=value 
2836          else: 
2837              self.__field_packet_size=UINT(value,**{ 'constant': 64 }) 
2838   
2839 -    def __delfield_packet_size(self): del self.__field_packet_size 
2840   
2841      packet_size=property(__getfield_packet_size, __setfield_packet_size, __delfield_packet_size, "Faster than packetsize()") 
2842   
2843 -    def __getfield_pos(self): 
2844          return self.__field_pos.getvalue() 
2845   
2846 -    def __setfield_pos(self, value): 
2847          if isinstance(value,UINT): 
2848              self.__field_pos=value 
2849          else: 
2850              self.__field_pos=UINT(value,**{'sizeinbytes': 4}) 
2851   
2852 -    def __delfield_pos(self): del self.__field_pos 
2853   
2854      pos=property(__getfield_pos, __setfield_pos, __delfield_pos, "position within file, used as an event id") 
2855   
2856 -    def __getfield_start(self): 
2857          return self.__field_start.getvalue() 
2858   
2859 -    def __setfield_start(self, value): 
2860          if isinstance(value,LGCALDATE): 
2861              self.__field_start=value 
2862          else: 
2863              self.__field_start=LGCALDATE(value,**{'sizeinbytes': 4}) 
2864   
2865 -    def __delfield_start(self): del self.__field_start 
2866   
2867      start=property(__getfield_start, __setfield_start, __delfield_start, None) 
2868   
2869 -    def __getfield_end(self): 
2870          return self.__field_end.getvalue() 
2871   
2872 -    def __setfield_end(self, value): 
2873          if isinstance(value,LGCALDATE): 
2874              self.__field_end=value 
2875          else: 
2876              self.__field_end=LGCALDATE(value,**{'sizeinbytes': 4}) 
2877   
2878 -    def __delfield_end(self): del self.__field_end 
2879   
2880      end=property(__getfield_end, __setfield_end, __delfield_end, None) 
2881   
2882 -    def __getfield_repeat(self): 
2883          return self.__field_repeat.getvalue() 
2884   
2885 -    def __setfield_repeat(self, value): 
2886          if isinstance(value,UINT): 
2887              self.__field_repeat=value 
2888          else: 
2889              self.__field_repeat=UINT(value,**{'sizeinbytes': 1}) 
2890   
2891 -    def __delfield_repeat(self): del self.__field_repeat 
2892   
2893      repeat=property(__getfield_repeat, __setfield_repeat, __delfield_repeat, None) 
2894   
2895 -    def __getfield_daybitmap(self): 
2896          return self.__field_daybitmap.getvalue() 
2897   
2898 -    def __setfield_daybitmap(self, value): 
2899          if isinstance(value,UINT): 
2900              self.__field_daybitmap=value 
2901          else: 
2902              self.__field_daybitmap=UINT(value,**{'sizeinbytes': 2}) 
2903   
2904 -    def __delfield_daybitmap(self): del self.__field_daybitmap 
2905   
2906      daybitmap=property(__getfield_daybitmap, __setfield_daybitmap, __delfield_daybitmap, "which days a weekly repeat event happens on") 
2907   
2908 -    def __getfield_pad2(self): 
2909          try: self.__field_pad2 
2910          except: 
2911              self.__field_pad2=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
2912          return self.__field_pad2.getvalue() 
2913   
2914 -    def __setfield_pad2(self, value): 
2915          if isinstance(value,UINT): 
2916              self.__field_pad2=value 
2917          else: 
2918              self.__field_pad2=UINT(value,**{'sizeinbytes': 1,  'default': 0 }) 
2919   
2920 -    def __delfield_pad2(self): del self.__field_pad2 
2921   
2922      pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None) 
2923   
2924 -    def __getfield_alarmminutes(self): 
2925          return self.__field_alarmminutes.getvalue() 
2926   
2927 -    def __setfield_alarmminutes(self, value): 
2928          if isinstance(value,UINT): 
2929              self.__field_alarmminutes=value 
2930          else: 
2931              self.__field_alarmminutes=UINT(value,**{'sizeinbytes': 1}) 
2932   
2933 -    def __delfield_alarmminutes(self): del self.__field_alarmminutes 
2934   
2935      alarmminutes=property(__getfield_alarmminutes, __setfield_alarmminutes, __delfield_alarmminutes, "a value of 100 indicates not set") 
2936   
2937 -    def __getfield_alarmhours(self): 
2938          return self.__field_alarmhours.getvalue() 
2939   
2940 -    def __setfield_alarmhours(self, value): 
2941          if isinstance(value,UINT): 
2942              self.__field_alarmhours=value 
2943          else: 
2944              self.__field_alarmhours=UINT(value,**{'sizeinbytes': 1}) 
2945   
2946 -    def __delfield_alarmhours(self): del self.__field_alarmhours 
2947   
2948      alarmhours=property(__getfield_alarmhours, __setfield_alarmhours, __delfield_alarmhours, "a value of 100 indicates not set") 
2949   
2950 -    def __getfield_alarmtype(self): 
2951          return self.__field_alarmtype.getvalue() 
2952   
2953 -    def __setfield_alarmtype(self, value): 
2954          if isinstance(value,UINT): 
2955              self.__field_alarmtype=value 
2956          else: 
2957              self.__field_alarmtype=UINT(value,**{'sizeinbytes': 1}) 
2958   
2959 -    def __delfield_alarmtype(self): del self.__field_alarmtype 
2960   
2961      alarmtype=property(__getfield_alarmtype, __setfield_alarmtype, __delfield_alarmtype, "preset alarm reminder type") 
2962   
2963 -    def __getfield_snoozedelay(self): 
2964          try: self.__field_snoozedelay 
2965          except: 
2966              self.__field_snoozedelay=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
2967          return self.__field_snoozedelay.getvalue() 
2968   
2969 -    def __setfield_snoozedelay(self, value): 
2970          if isinstance(value,UINT): 
2971              self.__field_snoozedelay=value 
2972          else: 
2973              self.__field_snoozedelay=UINT(value,**{'sizeinbytes': 1,  'default': 0 }) 
2974   
2975 -    def __delfield_snoozedelay(self): del self.__field_snoozedelay 
2976   
2977      snoozedelay=property(__getfield_snoozedelay, __setfield_snoozedelay, __delfield_snoozedelay, "in minutes, not for this phone") 
2978   
2979 -    def __getfield_ringtone(self): 
2980          return self.__field_ringtone.getvalue() 
2981   
2982 -    def __setfield_ringtone(self, value): 
2983          if isinstance(value,UINT): 
2984              self.__field_ringtone=value 
2985          else: 
2986              self.__field_ringtone=UINT(value,**{'sizeinbytes': 1}) 
2987   
2988 -    def __delfield_ringtone(self): del self.__field_ringtone 
2989   
2990      ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 
2991   
2992 -    def __getfield_description(self): 
2993          return self.__field_description.getvalue() 
2994   
2995 -    def __setfield_description(self, value): 
2996          if isinstance(value,USTRING): 
2997              self.__field_description=value 
2998          else: 
2999              self.__field_description=USTRING(value,**{'sizeinbytes': 35, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False }) 
3000   
3001 -    def __delfield_description(self): del self.__field_description 
3002   
3003      description=property(__getfield_description, __setfield_description, __delfield_description, None) 
3004   
3005 -    def __getfield_unknown1(self): 
3006          try: self.__field_unknown1 
3007          except: 
3008              self.__field_unknown1=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
3009          return self.__field_unknown1.getvalue() 
3010   
3011 -    def __setfield_unknown1(self, value): 
3012          if isinstance(value,UINT): 
3013              self.__field_unknown1=value 
3014          else: 
3015              self.__field_unknown1=UINT(value,**{'sizeinbytes': 2,  'default': 0 }) 
3016   
3017 -    def __delfield_unknown1(self): del self.__field_unknown1 
3018   
3019      unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, "This seems to always be two zeros") 
3020   
3021 -    def __getfield_hasvoice(self): 
3022          return self.__field_hasvoice.getvalue() 
3023   
3024 -    def __setfield_hasvoice(self, value): 
3025          if isinstance(value,UINT): 
3026              self.__field_hasvoice=value 
3027          else: 
3028              self.__field_hasvoice=UINT(value,**{'sizeinbytes': 2}) 
3029   
3030 -    def __delfield_hasvoice(self): del self.__field_hasvoice 
3031   
3032      hasvoice=property(__getfield_hasvoice, __setfield_hasvoice, __delfield_hasvoice, "This event has an associated voice memo if 1") 
3033   
3034 -    def __getfield_voiceid(self): 
3035          return self.__field_voiceid.getvalue() 
3036   
3037 -    def __setfield_voiceid(self, value): 
3038          if isinstance(value,UINT): 
3039              self.__field_voiceid=value 
3040          else: 
3041              self.__field_voiceid=UINT(value,**{'sizeinbytes': 2}) 
3042   
3043 -    def __delfield_voiceid(self): del self.__field_voiceid 
3044   
3045      voiceid=property(__getfield_voiceid, __setfield_voiceid, __delfield_voiceid, "sch/schexxx.qcp is the voice memo (xxx = voiceid - 0x0f)") 
3046   
3047 -    def __getfield_unknown2(self): 
3048          try: self.__field_unknown2 
3049          except: 
3050              self.__field_unknown2=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
3051          return self.__field_unknown2.getvalue() 
3052   
3053 -    def __setfield_unknown2(self, value): 
3054          if isinstance(value,UINT): 
3055              self.__field_unknown2=value 
3056          else: 
3057              self.__field_unknown2=UINT(value,**{'sizeinbytes': 2,  'default': 0 }) 
3058   
3059 -    def __delfield_unknown2(self): del self.__field_unknown2 
3060   
3061      unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, "This seems to always be yet two more zeros") 
3062   
3063 -    def iscontainer(self): 
3064          return True 
3065   
3066 -    def containerelements(self): 
3067          yield ('packet_size', self.__field_packet_size, "Faster than packetsize()") 
3068          yield ('pos', self.__field_pos, "position within file, used as an event id") 
3069          yield ('start', self.__field_start, None) 
3070          yield ('end', self.__field_end, None) 
3071          yield ('repeat', self.__field_repeat, None) 
3072          yield ('daybitmap', self.__field_daybitmap, "which days a weekly repeat event happens on") 
3073          yield ('pad2', self.__field_pad2, None) 
3074          yield ('alarmminutes', self.__field_alarmminutes, "a value of 100 indicates not set") 
3075          yield ('alarmhours', self.__field_alarmhours, "a value of 100 indicates not set") 
3076          yield ('alarmtype', self.__field_alarmtype, "preset alarm reminder type") 
3077          yield ('snoozedelay', self.__field_snoozedelay, "in minutes, not for this phone") 
3078          yield ('ringtone', self.__field_ringtone, None) 
3079          yield ('description', self.__field_description, None) 
3080          yield ('unknown1', self.__field_unknown1, "This seems to always be two zeros") 
3081          yield ('hasvoice', self.__field_hasvoice, "This event has an associated voice memo if 1") 
3082          yield ('voiceid', self.__field_voiceid, "sch/schexxx.qcp is the voice memo (xxx = voiceid - 0x0f)") 
3083          yield ('unknown2', self.__field_unknown2, "This seems to always be yet two more zeros") 
3084   
3085   
3086   
3087   
3088 -class schedulefile(BaseProtogenClass): 
3089      __fields=['numactiveitems', 'events'] 
3090   
3091 -    def __init__(self, *args, **kwargs): 
3092          dict={} 
3093          # What was supplied to this function 
3094          dict.update(kwargs) 
3095          # Parent constructor 
3096          super(schedulefile,self).__init__(**dict) 
3097          if self.__class__ is schedulefile: 
3098              self._update(args,dict) 
3099   
3100   
3101 -    def getfields(self): 
3102          return self.__fields 
3103   
3104   
3105 -    def _update(self, args, kwargs): 
3106          super(schedulefile,self)._update(args,kwargs) 
3107          keys=kwargs.keys() 
3108          for key in keys: 
3109              if key in self.__fields: 
3110                  setattr(self, key, kwargs[key]) 
3111                  del kwargs[key] 
3112          # Were any unrecognized kwargs passed in? 
3113          if __debug__: 
3114              self._complainaboutunusedargs(schedulefile,kwargs) 
3115          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
3116          # Make all P fields that haven't already been constructed 
3117   
3118   
3119 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3120          'Writes this packet to the supplied buffer' 
3121          self._bufferstartoffset=buf.getcurrentoffset() 
3122          self.__field_numactiveitems.writetobuffer(buf) 
3123          try: self.__field_events 
3124          except: 
3125              self.__field_events=LIST(**{'elementclass': scheduleevent}) 
3126          self.__field_events.writetobuffer(buf) 
3127          self._bufferendoffset=buf.getcurrentoffset() 
3128          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3129   
3130   
3131 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3132          'Reads this packet from the supplied buffer' 
3133          self._bufferstartoffset=buf.getcurrentoffset() 
3134          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3135          self.__field_numactiveitems=UINT(**{'sizeinbytes': 2}) 
3136          self.__field_numactiveitems.readfrombuffer(buf) 
3137          self.__field_events=LIST(**{'elementclass': scheduleevent}) 
3138          self.__field_events.readfrombuffer(buf) 
3139          self._bufferendoffset=buf.getcurrentoffset() 
3140   
3141   
3142 -    def __getfield_numactiveitems(self): 
3143          return self.__field_numactiveitems.getvalue() 
3144   
3145 -    def __setfield_numactiveitems(self, value): 
3146          if isinstance(value,UINT): 
3147              self.__field_numactiveitems=value 
3148          else: 
3149              self.__field_numactiveitems=UINT(value,**{'sizeinbytes': 2}) 
3150   
3151 -    def __delfield_numactiveitems(self): del self.__field_numactiveitems 
3152   
3153      numactiveitems=property(__getfield_numactiveitems, __setfield_numactiveitems, __delfield_numactiveitems, None) 
3154   
3155 -    def __getfield_events(self): 
3156          try: self.__field_events 
3157          except: 
3158              self.__field_events=LIST(**{'elementclass': scheduleevent}) 
3159          return self.__field_events.getvalue() 
3160   
3161 -    def __setfield_events(self, value): 
3162          if isinstance(value,LIST): 
3163              self.__field_events=value 
3164          else: 
3165              self.__field_events=LIST(value,**{'elementclass': scheduleevent}) 
3166   
3167 -    def __delfield_events(self): del self.__field_events 
3168   
3169      events=property(__getfield_events, __setfield_events, __delfield_events, None) 
3170   
3171 -    def iscontainer(self): 
3172          return True 
3173   
3174 -    def containerelements(self): 
3175          yield ('numactiveitems', self.__field_numactiveitems, None) 
3176          yield ('events', self.__field_events, None) 
3177   
3178   
3179   
3180   
3181 -class recipient_record(BaseProtogenClass): 
3182      __fields=['unknown1', 'name', 'number', 'unknown2', 'status', 'time'] 
3183   
3184 -    def __init__(self, *args, **kwargs): 
3185          dict={} 
3186          # What was supplied to this function 
3187          dict.update(kwargs) 
3188          # Parent constructor 
3189          super(recipient_record,self).__init__(**dict) 
3190          if self.__class__ is recipient_record: 
3191              self._update(args,dict) 
3192   
3193   
3194 -    def getfields(self): 
3195          return self.__fields 
3196   
3197   
3198 -    def _update(self, args, kwargs): 
3199          super(recipient_record,self)._update(args,kwargs) 
3200          keys=kwargs.keys() 
3201          for key in keys: 
3202              if key in self.__fields: 
3203                  setattr(self, key, kwargs[key]) 
3204                  del kwargs[key] 
3205          # Were any unrecognized kwargs passed in? 
3206          if __debug__: 
3207              self._complainaboutunusedargs(recipient_record,kwargs) 
3208          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
3209          # Make all P fields that haven't already been constructed 
3210          try: self.__field_name 
3211          except: 
3212              self.__field_name=USTRING(**{'encoding': PHONE_ENCODING, 'default':'', 'raiseonunterminatedread': False}) 
3213   
3214   
3215 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3216          'Writes this packet to the supplied buffer' 
3217          self._bufferstartoffset=buf.getcurrentoffset() 
3218          self.__field_unknown1.writetobuffer(buf) 
3219          self.__field_number.writetobuffer(buf) 
3220          self.__field_unknown2.writetobuffer(buf) 
3221          self.__field_status.writetobuffer(buf) 
3222          self.__field_time.writetobuffer(buf) 
3223          self._bufferendoffset=buf.getcurrentoffset() 
3224          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3225   
3226   
3227 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3228          'Reads this packet from the supplied buffer' 
3229          self._bufferstartoffset=buf.getcurrentoffset() 
3230          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3231          self.__field_unknown1=UINT(**{'sizeinbytes': 20}) 
3232          self.__field_unknown1.readfrombuffer(buf) 
3233          self.__field_number=USTRING(**{'sizeinbytes': 49}) 
3234          self.__field_number.readfrombuffer(buf) 
3235          self.__field_unknown2=UINT(**{'sizeinbytes': 24}) 
3236          self.__field_unknown2.readfrombuffer(buf) 
3237          self.__field_status=UINT(**{'sizeinbytes': 1}) 
3238          self.__field_status.readfrombuffer(buf) 
3239          self.__field_time=LGCALDATE(**{'sizeinbytes': 4}) 
3240          self.__field_time.readfrombuffer(buf) 
3241          self._bufferendoffset=buf.getcurrentoffset() 
3242   
3243   
3244 -    def __getfield_unknown1(self): 
3245          return self.__field_unknown1.getvalue() 
3246   
3247 -    def __setfield_unknown1(self, value): 
3248          if isinstance(value,UINT): 
3249              self.__field_unknown1=value 
3250          else: 
3251              self.__field_unknown1=UINT(value,**{'sizeinbytes': 20}) 
3252   
3253 -    def __delfield_unknown1(self): del self.__field_unknown1 
3254   
3255      unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 
3256   
3257 -    def __getfield_name(self): 
3258          return self.__field_name.getvalue() 
3259   
3260 -    def __setfield_name(self, value): 
3261          if isinstance(value,USTRING): 
3262              self.__field_name=value 
3263          else: 
3264              self.__field_name=USTRING(value,**{'encoding': PHONE_ENCODING, 'default':'', 'raiseonunterminatedread': False}) 
3265   
3266 -    def __delfield_name(self): del self.__field_name 
3267   
3268      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
3269   
3270 -    def __getfield_number(self): 
3271          return self.__field_number.getvalue() 
3272   
3273 -    def __setfield_number(self, value): 
3274          if isinstance(value,USTRING): 
3275              self.__field_number=value 
3276          else: 
3277              self.__field_number=USTRING(value,**{'sizeinbytes': 49}) 
3278   
3279 -    def __delfield_number(self): del self.__field_number 
3280   
3281      number=property(__getfield_number, __setfield_number, __delfield_number, None) 
3282   
3283 -    def __getfield_unknown2(self): 
3284          return self.__field_unknown2.getvalue() 
3285   
3286 -    def __setfield_unknown2(self, value): 
3287          if isinstance(value,UINT): 
3288              self.__field_unknown2=value 
3289          else: 
3290              self.__field_unknown2=UINT(value,**{'sizeinbytes': 24}) 
3291   
3292 -    def __delfield_unknown2(self): del self.__field_unknown2 
3293   
3294      unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None) 
3295   
3296 -    def __getfield_status(self): 
3297          return self.__field_status.getvalue() 
3298   
3299 -    def __setfield_status(self, value): 
3300          if isinstance(value,UINT): 
3301              self.__field_status=value 
3302          else: 
3303              self.__field_status=UINT(value,**{'sizeinbytes': 1}) 
3304   
3305 -    def __delfield_status(self): del self.__field_status 
3306   
3307      status=property(__getfield_status, __setfield_status, __delfield_status, None) 
3308   
3309 -    def __getfield_time(self): 
3310          return self.__field_time.getvalue() 
3311   
3312 -    def __setfield_time(self, value): 
3313          if isinstance(value,LGCALDATE): 
3314              self.__field_time=value 
3315          else: 
3316              self.__field_time=LGCALDATE(value,**{'sizeinbytes': 4}) 
3317   
3318 -    def __delfield_time(self): del self.__field_time 
3319   
3320      time=property(__getfield_time, __setfield_time, __delfield_time, None) 
3321   
3322 -    def iscontainer(self): 
3323          return True 
3324   
3325 -    def containerelements(self): 
3326          yield ('unknown1', self.__field_unknown1, None) 
3327          yield ('name', self.__field_name, None) 
3328          yield ('number', self.__field_number, None) 
3329          yield ('unknown2', self.__field_unknown2, None) 
3330          yield ('status', self.__field_status, None) 
3331          yield ('time', self.__field_time, None) 
3332   
3333   
3334   
3335   
3336 -class sms_saved(BaseProtogenClass): 
3337      __fields=['outboxmsg', 'GPStime', 'outbox', 'inbox'] 
3338   
3339 -    def __init__(self, *args, **kwargs): 
3340          dict={} 
3341          # What was supplied to this function 
3342          dict.update(kwargs) 
3343          # Parent constructor 
3344          super(sms_saved,self).__init__(**dict) 
3345          if self.__class__ is sms_saved: 
3346              self._update(args,dict) 
3347   
3348   
3349 -    def getfields(self): 
3350          return self.__fields 
3351   
3352   
3353 -    def _update(self, args, kwargs): 
3354          super(sms_saved,self)._update(args,kwargs) 
3355          keys=kwargs.keys() 
3356          for key in keys: 
3357              if key in self.__fields: 
3358                  setattr(self, key, kwargs[key]) 
3359                  del kwargs[key] 
3360          # Were any unrecognized kwargs passed in? 
3361          if __debug__: 
3362              self._complainaboutunusedargs(sms_saved,kwargs) 
3363          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
3364          # Make all P fields that haven't already been constructed 
3365   
3366   
3367 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3368          'Writes this packet to the supplied buffer' 
3369          self._bufferstartoffset=buf.getcurrentoffset() 
3370          self.__field_outboxmsg.writetobuffer(buf) 
3371          self.__field_GPStime.writetobuffer(buf) 
3372          if self.outboxmsg: 
3373              self.__field_outbox.writetobuffer(buf) 
3374          if not self.outboxmsg: 
3375              self.__field_inbox.writetobuffer(buf) 
3376          self._bufferendoffset=buf.getcurrentoffset() 
3377          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3378   
3379   
3380 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3381          'Reads this packet from the supplied buffer' 
3382          self._bufferstartoffset=buf.getcurrentoffset() 
3383          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3384          self.__field_outboxmsg=UINT(**{'sizeinbytes': 4}) 
3385          self.__field_outboxmsg.readfrombuffer(buf) 
3386          self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4}) 
3387          self.__field_GPStime.readfrombuffer(buf) 
3388          if self.outboxmsg: 
3389              self.__field_outbox=sms_out() 
3390              self.__field_outbox.readfrombuffer(buf) 
3391          if not self.outboxmsg: 
3392              self.__field_inbox=sms_in() 
3393              self.__field_inbox.readfrombuffer(buf) 
3394          self._bufferendoffset=buf.getcurrentoffset() 
3395   
3396   
3397 -    def __getfield_outboxmsg(self): 
3398          return self.__field_outboxmsg.getvalue() 
3399   
3400 -    def __setfield_outboxmsg(self, value): 
3401          if isinstance(value,UINT): 
3402              self.__field_outboxmsg=value 
3403          else: 
3404              self.__field_outboxmsg=UINT(value,**{'sizeinbytes': 4}) 
3405   
3406 -    def __delfield_outboxmsg(self): del self.__field_outboxmsg 
3407   
3408      outboxmsg=property(__getfield_outboxmsg, __setfield_outboxmsg, __delfield_outboxmsg, None) 
3409   
3410 -    def __getfield_GPStime(self): 
3411          return self.__field_GPStime.getvalue() 
3412   
3413 -    def __setfield_GPStime(self, value): 
3414          if isinstance(value,GPSDATE): 
3415              self.__field_GPStime=value 
3416          else: 
3417              self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4}) 
3418   
3419 -    def __delfield_GPStime(self): del self.__field_GPStime 
3420   
3421      GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None) 
3422   
3423 -    def __getfield_outbox(self): 
3424          return self.__field_outbox.getvalue() 
3425   
3426 -    def __setfield_outbox(self, value): 
3427          if isinstance(value,sms_out): 
3428              self.__field_outbox=value 
3429          else: 
3430              self.__field_outbox=sms_out(value,) 
3431   
3432 -    def __delfield_outbox(self): del self.__field_outbox 
3433   
3434      outbox=property(__getfield_outbox, __setfield_outbox, __delfield_outbox, None) 
3435   
3436 -    def __getfield_inbox(self): 
3437          return self.__field_inbox.getvalue() 
3438   
3439 -    def __setfield_inbox(self, value): 
3440          if isinstance(value,sms_in): 
3441              self.__field_inbox=value 
3442          else: 
3443              self.__field_inbox=sms_in(value,) 
3444   
3445 -    def __delfield_inbox(self): del self.__field_inbox 
3446   
3447      inbox=property(__getfield_inbox, __setfield_inbox, __delfield_inbox, None) 
3448   
3449 -    def iscontainer(self): 
3450          return True 
3451   
3452 -    def containerelements(self): 
3453          yield ('outboxmsg', self.__field_outboxmsg, None) 
3454          yield ('GPStime', self.__field_GPStime, None) 
3455          if self.outboxmsg: 
3456              yield ('outbox', self.__field_outbox, None) 
3457          if not self.outboxmsg: 
3458              yield ('inbox', self.__field_inbox, None) 
3459   
3460   
3461   
3462   
3463 -class sms_out(BaseProtogenClass): 
3464      __fields=['index', 'locked', 'unknown1', 'timesent', 'msg', 'unknown2', 'callback', 'recipients'] 
3465   
3466 -    def __init__(self, *args, **kwargs): 
3467          dict={} 
3468          # What was supplied to this function 
3469          dict.update(kwargs) 
3470          # Parent constructor 
3471          super(sms_out,self).__init__(**dict) 
3472          if self.__class__ is sms_out: 
3473              self._update(args,dict) 
3474   
3475   
3476 -    def getfields(self): 
3477          return self.__fields 
3478   
3479   
3480 -    def _update(self, args, kwargs): 
3481          super(sms_out,self)._update(args,kwargs) 
3482          keys=kwargs.keys() 
3483          for key in keys: 
3484              if key in self.__fields: 
3485                  setattr(self, key, kwargs[key]) 
3486                  del kwargs[key] 
3487          # Were any unrecognized kwargs passed in? 
3488          if __debug__: 
3489              self._complainaboutunusedargs(sms_out,kwargs) 
3490          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
3491          # Make all P fields that haven't already been constructed 
3492   
3493   
3494 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3495          'Writes this packet to the supplied buffer' 
3496          self._bufferstartoffset=buf.getcurrentoffset() 
3497          self.__field_index.writetobuffer(buf) 
3498          self.__field_locked.writetobuffer(buf) 
3499          self.__field_unknown1.writetobuffer(buf) 
3500          self.__field_timesent.writetobuffer(buf) 
3501          self.__field_msg.writetobuffer(buf) 
3502          self.__field_unknown2.writetobuffer(buf) 
3503          self.__field_callback.writetobuffer(buf) 
3504          try: self.__field_recipients 
3505          except: 
3506              self.__field_recipients=LIST(**{'elementclass': recipient_record, 'length': 10}) 
3507          self.__field_recipients.writetobuffer(buf) 
3508          self._bufferendoffset=buf.getcurrentoffset() 
3509          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3510   
3511   
3512 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3513          'Reads this packet from the supplied buffer' 
3514          self._bufferstartoffset=buf.getcurrentoffset() 
3515          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3516          self.__field_index=UINT(**{'sizeinbytes': 4}) 
3517          self.__field_index.readfrombuffer(buf) 
3518          self.__field_locked=UINT(**{'sizeinbytes': 1}) 
3519          self.__field_locked.readfrombuffer(buf) 
3520          self.__field_unknown1=UINT(**{'sizeinbytes': 3}) 
3521          self.__field_unknown1.readfrombuffer(buf) 
3522          self.__field_timesent=LGCALDATE(**{'sizeinbytes': 4}) 
3523          self.__field_timesent.readfrombuffer(buf) 
3524          self.__field_msg=USTRING(**{'sizeinbytes': 500, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
3525          self.__field_msg.readfrombuffer(buf) 
3526          self.__field_unknown2=DATA(**{'sizeinbytes': 1250}) 
3527          self.__field_unknown2.readfrombuffer(buf) 
3528          self.__field_callback=USTRING(**{'sizeinbytes': 16}) 
3529          self.__field_callback.readfrombuffer(buf) 
3530          self.__field_recipients=LIST(**{'elementclass': recipient_record, 'length': 10}) 
3531          self.__field_recipients.readfrombuffer(buf) 
3532          self._bufferendoffset=buf.getcurrentoffset() 
3533   
3534   
3535 -    def __getfield_index(self): 
3536          return self.__field_index.getvalue() 
3537   
3538 -    def __setfield_index(self, value): 
3539          if isinstance(value,UINT): 
3540              self.__field_index=value 
3541          else: 
3542              self.__field_index=UINT(value,**{'sizeinbytes': 4}) 
3543   
3544 -    def __delfield_index(self): del self.__field_index 
3545   
3546      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
3547   
3548 -    def __getfield_locked(self): 
3549          return self.__field_locked.getvalue() 
3550   
3551 -    def __setfield_locked(self, value): 
3552          if isinstance(value,UINT): 
3553              self.__field_locked=value 
3554          else: 
3555              self.__field_locked=UINT(value,**{'sizeinbytes': 1}) 
3556   
3557 -    def __delfield_locked(self): del self.__field_locked 
3558   
3559      locked=property(__getfield_locked, __setfield_locked, __delfield_locked, None) 
3560   
3561 -    def __getfield_unknown1(self): 
3562          return self.__field_unknown1.getvalue() 
3563   
3564 -    def __setfield_unknown1(self, value): 
3565          if isinstance(value,UINT): 
3566              self.__field_unknown1=value 
3567          else: 
3568              self.__field_unknown1=UINT(value,**{'sizeinbytes': 3}) 
3569   
3570 -    def __delfield_unknown1(self): del self.__field_unknown1 
3571   
3572      unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 
3573   
3574 -    def __getfield_timesent(self): 
3575          return self.__field_timesent.getvalue() 
3576   
3577 -    def __setfield_timesent(self, value): 
3578          if isinstance(value,LGCALDATE): 
3579              self.__field_timesent=value 
3580          else: 
3581              self.__field_timesent=LGCALDATE(value,**{'sizeinbytes': 4}) 
3582   
3583 -    def __delfield_timesent(self): del self.__field_timesent 
3584   
3585      timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None) 
3586   
3587 -    def __getfield_msg(self): 
3588          return self.__field_msg.getvalue() 
3589   
3590 -    def __setfield_msg(self, value): 
3591          if isinstance(value,USTRING): 
3592              self.__field_msg=value 
3593          else: 
3594              self.__field_msg=USTRING(value,**{'sizeinbytes': 500, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
3595   
3596 -    def __delfield_msg(self): del self.__field_msg 
3597   
3598      msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None) 
3599   
3600 -    def __getfield_unknown2(self): 
3601          return self.__field_unknown2.getvalue() 
3602   
3603 -    def __setfield_unknown2(self, value): 
3604          if isinstance(value,DATA): 
3605              self.__field_unknown2=value 
3606          else: 
3607              self.__field_unknown2=DATA(value,**{'sizeinbytes': 1250}) 
3608   
3609 -    def __delfield_unknown2(self): del self.__field_unknown2 
3610   
3611      unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None) 
3612   
3613 -    def __getfield_callback(self): 
3614          return self.__field_callback.getvalue() 
3615   
3616 -    def __setfield_callback(self, value): 
3617          if isinstance(value,USTRING): 
3618              self.__field_callback=value 
3619          else: 
3620              self.__field_callback=USTRING(value,**{'sizeinbytes': 16}) 
3621   
3622 -    def __delfield_callback(self): del self.__field_callback 
3623   
3624      callback=property(__getfield_callback, __setfield_callback, __delfield_callback, None) 
3625   
3626 -    def __getfield_recipients(self): 
3627          try: self.__field_recipients 
3628          except: 
3629              self.__field_recipients=LIST(**{'elementclass': recipient_record, 'length': 10}) 
3630          return self.__field_recipients.getvalue() 
3631   
3632 -    def __setfield_recipients(self, value): 
3633          if isinstance(value,LIST): 
3634              self.__field_recipients=value 
3635          else: 
3636              self.__field_recipients=LIST(value,**{'elementclass': recipient_record, 'length': 10}) 
3637   
3638 -    def __delfield_recipients(self): del self.__field_recipients 
3639   
3640      recipients=property(__getfield_recipients, __setfield_recipients, __delfield_recipients, None) 
3641   
3642 -    def iscontainer(self): 
3643          return True 
3644   
3645 -    def containerelements(self): 
3646          yield ('index', self.__field_index, None) 
3647          yield ('locked', self.__field_locked, None) 
3648          yield ('unknown1', self.__field_unknown1, None) 
3649          yield ('timesent', self.__field_timesent, None) 
3650          yield ('msg', self.__field_msg, None) 
3651          yield ('unknown2', self.__field_unknown2, None) 
3652          yield ('callback', self.__field_callback, None) 
3653          yield ('recipients', self.__field_recipients, None) 
3654   
3655   
3656   
3657   
3658 -class SMSINBOXMSGFRAGMENT(BaseProtogenClass): 
3659      __fields=['msg'] 
3660   
3661 -    def __init__(self, *args, **kwargs): 
3662          dict={} 
3663          # What was supplied to this function 
3664          dict.update(kwargs) 
3665          # Parent constructor 
3666          super(SMSINBOXMSGFRAGMENT,self).__init__(**dict) 
3667          if self.__class__ is SMSINBOXMSGFRAGMENT: 
3668              self._update(args,dict) 
3669   
3670   
3671 -    def getfields(self): 
3672          return self.__fields 
3673   
3674   
3675 -    def _update(self, args, kwargs): 
3676          super(SMSINBOXMSGFRAGMENT,self)._update(args,kwargs) 
3677          keys=kwargs.keys() 
3678          for key in keys: 
3679              if key in self.__fields: 
3680                  setattr(self, key, kwargs[key]) 
3681                  del kwargs[key] 
3682          # Were any unrecognized kwargs passed in? 
3683          if __debug__: 
3684              self._complainaboutunusedargs(SMSINBOXMSGFRAGMENT,kwargs) 
3685          if len(args): 
3686              dict2={'elementclass': _gen_p_lglg6190_321, 'length': 181} 
3687              dict2.update(kwargs) 
3688              kwargs=dict2 
3689              self.__field_msg=LIST(*args,**dict2) 
3690          # Make all P fields that haven't already been constructed 
3691   
3692   
3693 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3694          'Writes this packet to the supplied buffer' 
3695          self._bufferstartoffset=buf.getcurrentoffset() 
3696          try: self.__field_msg 
3697          except: 
3698              self.__field_msg=LIST(**{'elementclass': _gen_p_lglg6190_321, 'length': 181}) 
3699          self.__field_msg.writetobuffer(buf) 
3700          self._bufferendoffset=buf.getcurrentoffset() 
3701          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3702   
3703   
3704 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3705          'Reads this packet from the supplied buffer' 
3706          self._bufferstartoffset=buf.getcurrentoffset() 
3707          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3708          self.__field_msg=LIST(**{'elementclass': _gen_p_lglg6190_321, 'length': 181}) 
3709          self.__field_msg.readfrombuffer(buf) 
3710          self._bufferendoffset=buf.getcurrentoffset() 
3711   
3712   
3713 -    def __getfield_msg(self): 
3714          try: self.__field_msg 
3715          except: 
3716              self.__field_msg=LIST(**{'elementclass': _gen_p_lglg6190_321, 'length': 181}) 
3717          return self.__field_msg.getvalue() 
3718   
3719 -    def __setfield_msg(self, value): 
3720          if isinstance(value,LIST): 
3721              self.__field_msg=value 
3722          else: 
3723              self.__field_msg=LIST(value,**{'elementclass': _gen_p_lglg6190_321, 'length': 181}) 
3724   
3725 -    def __delfield_msg(self): del self.__field_msg 
3726   
3727      msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None) 
3728   
3729 -    def iscontainer(self): 
3730          return True 
3731   
3732 -    def containerelements(self): 
3733          yield ('msg', self.__field_msg, None) 
3734   
3735   
3736   
3737   
3738 -class _gen_p_lglg6190_321(BaseProtogenClass): 
3739      'Anonymous inner class' 
3740      __fields=['byte'] 
3741   
3742 -    def __init__(self, *args, **kwargs): 
3743          dict={} 
3744          # What was supplied to this function 
3745          dict.update(kwargs) 
3746          # Parent constructor 
3747          super(_gen_p_lglg6190_321,self).__init__(**dict) 
3748          if self.__class__ is _gen_p_lglg6190_321: 
3749              self._update(args,dict) 
3750   
3751   
3752 -    def getfields(self): 
3753          return self.__fields 
3754   
3755   
3756 -    def _update(self, args, kwargs): 
3757          super(_gen_p_lglg6190_321,self)._update(args,kwargs) 
3758          keys=kwargs.keys() 
3759          for key in keys: 
3760              if key in self.__fields: 
3761                  setattr(self, key, kwargs[key]) 
3762                  del kwargs[key] 
3763          # Were any unrecognized kwargs passed in? 
3764          if __debug__: 
3765              self._complainaboutunusedargs(_gen_p_lglg6190_321,kwargs) 
3766          if len(args): 
3767              dict2={'sizeinbytes': 1} 
3768              dict2.update(kwargs) 
3769              kwargs=dict2 
3770              self.__field_byte=UINT(*args,**dict2) 
3771          # Make all P fields that haven't already been constructed 
3772   
3773   
3774 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3775          'Writes this packet to the supplied buffer' 
3776          self._bufferstartoffset=buf.getcurrentoffset() 
3777          self.__field_byte.writetobuffer(buf) 
3778          self._bufferendoffset=buf.getcurrentoffset() 
3779          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3780   
3781   
3782 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3783          'Reads this packet from the supplied buffer' 
3784          self._bufferstartoffset=buf.getcurrentoffset() 
3785          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3786          self.__field_byte=UINT(**{'sizeinbytes': 1}) 
3787          self.__field_byte.readfrombuffer(buf) 
3788          self._bufferendoffset=buf.getcurrentoffset() 
3789   
3790   
3791 -    def __getfield_byte(self): 
3792          return self.__field_byte.getvalue() 
3793   
3794 -    def __setfield_byte(self, value): 
3795          if isinstance(value,UINT): 
3796              self.__field_byte=value 
3797          else: 
3798              self.__field_byte=UINT(value,**{'sizeinbytes': 1}) 
3799   
3800 -    def __delfield_byte(self): del self.__field_byte 
3801   
3802      byte=property(__getfield_byte, __setfield_byte, __delfield_byte, "individual byte of message") 
3803   
3804 -    def iscontainer(self): 
3805          return True 
3806   
3807 -    def containerelements(self): 
3808          yield ('byte', self.__field_byte, "individual byte of message") 
3809   
3810   
3811   
3812   
3813 -class sms_in(BaseProtogenClass): 
3814      __fields=['unknown1', 'msg_index2', 'unknown2', 'timesent', 'unknown', 'callback_length', 'callback', 'sender_length', 'sender', 'unknown4', 'lg_time', 'GPStime', 'unknown41', 'read', 'unknown5', 'subject', 'unknown6', 'msglength', 'unknown7', 'msg', 'unknown8'] 
3815   
3816 -    def __init__(self, *args, **kwargs): 
3817          dict={} 
3818          # What was supplied to this function 
3819          dict.update(kwargs) 
3820          # Parent constructor 
3821          super(sms_in,self).__init__(**dict) 
3822          if self.__class__ is sms_in: 
3823              self._update(args,dict) 
3824   
3825   
3826 -    def getfields(self): 
3827          return self.__fields 
3828   
3829   
3830 -    def _update(self, args, kwargs): 
3831          super(sms_in,self)._update(args,kwargs) 
3832          keys=kwargs.keys() 
3833          for key in keys: 
3834              if key in self.__fields: 
3835                  setattr(self, key, kwargs[key]) 
3836                  del kwargs[key] 
3837          # Were any unrecognized kwargs passed in? 
3838          if __debug__: 
3839              self._complainaboutunusedargs(sms_in,kwargs) 
3840          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
3841          # Make all P fields that haven't already been constructed 
3842   
3843   
3844 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3845          'Writes this packet to the supplied buffer' 
3846          self._bufferstartoffset=buf.getcurrentoffset() 
3847          self.__field_unknown1.writetobuffer(buf) 
3848          self.__field_msg_index2.writetobuffer(buf) 
3849          self.__field_unknown2.writetobuffer(buf) 
3850          self.__field_timesent.writetobuffer(buf) 
3851          self.__field_unknown.writetobuffer(buf) 
3852          self.__field_callback_length.writetobuffer(buf) 
3853          self.__field_callback.writetobuffer(buf) 
3854          self.__field_sender_length.writetobuffer(buf) 
3855          try: self.__field_sender 
3856          except: 
3857              self.__field_sender=LIST(**{'elementclass': _gen_p_lglg6190_333, 'length': 38}) 
3858          self.__field_sender.writetobuffer(buf) 
3859          self.__field_unknown4.writetobuffer(buf) 
3860          self.__field_lg_time.writetobuffer(buf) 
3861          self.__field_GPStime.writetobuffer(buf) 
3862          self.__field_unknown41.writetobuffer(buf) 
3863          self.__field_read.writetobuffer(buf) 
3864          self.__field_unknown5.writetobuffer(buf) 
3865          self.__field_subject.writetobuffer(buf) 
3866          self.__field_unknown6.writetobuffer(buf) 
3867          self.__field_msglength.writetobuffer(buf) 
3868          self.__field_unknown7.writetobuffer(buf) 
3869          self.__field_msg.writetobuffer(buf) 
3870          self.__field_unknown8.writetobuffer(buf) 
3871          self._bufferendoffset=buf.getcurrentoffset() 
3872          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3873   
3874   
3875 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3876          'Reads this packet from the supplied buffer' 
3877          self._bufferstartoffset=buf.getcurrentoffset() 
3878          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3879          self.__field_unknown1=UINT(**{'sizeinbytes': 4}) 
3880          self.__field_unknown1.readfrombuffer(buf) 
3881          self.__field_msg_index2=UINT(**{'sizeinbytes': 4}) 
3882          self.__field_msg_index2.readfrombuffer(buf) 
3883          self.__field_unknown2=UINT(**{'sizeinbytes': 6}) 
3884          self.__field_unknown2.readfrombuffer(buf) 
3885          self.__field_timesent=SMSDATE(**{'sizeinbytes': 6}) 
3886          self.__field_timesent.readfrombuffer(buf) 
3887          self.__field_unknown=UINT(**{'sizeinbytes': 3}) 
3888          self.__field_unknown.readfrombuffer(buf) 
3889          self.__field_callback_length=UINT(**{'sizeinbytes': 1}) 
3890          self.__field_callback_length.readfrombuffer(buf) 
3891          self.__field_callback=USTRING(**{'sizeinbytes': 38}) 
3892          self.__field_callback.readfrombuffer(buf) 
3893          self.__field_sender_length=UINT(**{'sizeinbytes': 1}) 
3894          self.__field_sender_length.readfrombuffer(buf) 
3895          self.__field_sender=LIST(**{'elementclass': _gen_p_lglg6190_333, 'length': 38}) 
3896          self.__field_sender.readfrombuffer(buf) 
3897          self.__field_unknown4=DATA(**{'sizeinbytes': 15}) 
3898          self.__field_unknown4.readfrombuffer(buf) 
3899          self.__field_lg_time=LGCALDATE(**{'sizeinbytes': 4}) 
3900          self.__field_lg_time.readfrombuffer(buf) 
3901          self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4}) 
3902          self.__field_GPStime.readfrombuffer(buf) 
3903          self.__field_unknown41=UINT(**{'sizeinbytes': 2}) 
3904          self.__field_unknown41.readfrombuffer(buf) 
3905          self.__field_read=UINT(**{'sizeinbytes': 2}) 
3906          self.__field_read.readfrombuffer(buf) 
3907          self.__field_unknown5=UINT(**{'sizeinbytes': 9}) 
3908          self.__field_unknown5.readfrombuffer(buf) 
3909          self.__field_subject=USTRING(**{'sizeinbytes': 21, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
3910          self.__field_subject.readfrombuffer(buf) 
3911          self.__field_unknown6=UINT(**{'sizeinbytes': 8}) 
3912          self.__field_unknown6.readfrombuffer(buf) 
3913          self.__field_msglength=UINT(**{'sizeinbytes': 2}) 
3914          self.__field_msglength.readfrombuffer(buf) 
3915          self.__field_unknown7=UINT(**{'sizeinbytes': 18}) 
3916          self.__field_unknown7.readfrombuffer(buf) 
3917          self.__field_msg=USTRING(**{'sizeinbytes': 200, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
3918          self.__field_msg.readfrombuffer(buf) 
3919          self.__field_unknown8=DATA() 
3920          self.__field_unknown8.readfrombuffer(buf) 
3921          self._bufferendoffset=buf.getcurrentoffset() 
3922   
3923   
3924 -    def __getfield_unknown1(self): 
3925          return self.__field_unknown1.getvalue() 
3926   
3927 -    def __setfield_unknown1(self, value): 
3928          if isinstance(value,UINT): 
3929              self.__field_unknown1=value 
3930          else: 
3931              self.__field_unknown1=UINT(value,**{'sizeinbytes': 4}) 
3932   
3933 -    def __delfield_unknown1(self): del self.__field_unknown1 
3934   
3935      unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 
3936   
3937 -    def __getfield_msg_index2(self): 
3938          return self.__field_msg_index2.getvalue() 
3939   
3940 -    def __setfield_msg_index2(self, value): 
3941          if isinstance(value,UINT): 
3942              self.__field_msg_index2=value 
3943          else: 
3944              self.__field_msg_index2=UINT(value,**{'sizeinbytes': 4}) 
3945   
3946 -    def __delfield_msg_index2(self): del self.__field_msg_index2 
3947   
3948      msg_index2=property(__getfield_msg_index2, __setfield_msg_index2, __delfield_msg_index2, None) 
3949   
3950 -    def __getfield_unknown2(self): 
3951          return self.__field_unknown2.getvalue() 
3952   
3953 -    def __setfield_unknown2(self, value): 
3954          if isinstance(value,UINT): 
3955              self.__field_unknown2=value 
3956          else: 
3957              self.__field_unknown2=UINT(value,**{'sizeinbytes': 6}) 
3958   
3959 -    def __delfield_unknown2(self): del self.__field_unknown2 
3960   
3961      unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None) 
3962   
3963 -    def __getfield_timesent(self): 
3964          return self.__field_timesent.getvalue() 
3965   
3966 -    def __setfield_timesent(self, value): 
3967          if isinstance(value,SMSDATE): 
3968              self.__field_timesent=value 
3969          else: 
3970              self.__field_timesent=SMSDATE(value,**{'sizeinbytes': 6}) 
3971   
3972 -    def __delfield_timesent(self): del self.__field_timesent 
3973   
3974      timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None) 
3975   
3976 -    def __getfield_unknown(self): 
3977          return self.__field_unknown.getvalue() 
3978   
3979 -    def __setfield_unknown(self, value): 
3980          if isinstance(value,UINT): 
3981              self.__field_unknown=value 
3982          else: 
3983              self.__field_unknown=UINT(value,**{'sizeinbytes': 3}) 
3984   
3985 -    def __delfield_unknown(self): del self.__field_unknown 
3986   
3987      unknown=property(__getfield_unknown, __setfield_unknown, __delfield_unknown, None) 
3988   
3989 -    def __getfield_callback_length(self): 
3990          return self.__field_callback_length.getvalue() 
3991   
3992 -    def __setfield_callback_length(self, value): 
3993          if isinstance(value,UINT): 
3994              self.__field_callback_length=value 
3995          else: 
3996              self.__field_callback_length=UINT(value,**{'sizeinbytes': 1}) 
3997   
3998 -    def __delfield_callback_length(self): del self.__field_callback_length 
3999   
4000      callback_length=property(__getfield_callback_length, __setfield_callback_length, __delfield_callback_length, None) 
4001   
4002 -    def __getfield_callback(self): 
4003          return self.__field_callback.getvalue() 
4004   
4005 -    def __setfield_callback(self, value): 
4006          if isinstance(value,USTRING): 
4007              self.__field_callback=value 
4008          else: 
4009              self.__field_callback=USTRING(value,**{'sizeinbytes': 38}) 
4010   
4011 -    def __delfield_callback(self): del self.__field_callback 
4012   
4013      callback=property(__getfield_callback, __setfield_callback, __delfield_callback, None) 
4014   
4015 -    def __getfield_sender_length(self): 
4016          return self.__field_sender_length.getvalue() 
4017   
4018 -    def __setfield_sender_length(self, value): 
4019          if isinstance(value,UINT): 
4020              self.__field_sender_length=value 
4021          else: 
4022              self.__field_sender_length=UINT(value,**{'sizeinbytes': 1}) 
4023   
4024 -    def __delfield_sender_length(self): del self.__field_sender_length 
4025   
4026      sender_length=property(__getfield_sender_length, __setfield_sender_length, __delfield_sender_length, None) 
4027   
4028 -    def __getfield_sender(self): 
4029          try: self.__field_sender 
4030          except: 
4031              self.__field_sender=LIST(**{'elementclass': _gen_p_lglg6190_333, 'length': 38}) 
4032          return self.__field_sender.getvalue() 
4033   
4034 -    def __setfield_sender(self, value): 
4035          if isinstance(value,LIST): 
4036              self.__field_sender=value 
4037          else: 
4038              self.__field_sender=LIST(value,**{'elementclass': _gen_p_lglg6190_333, 'length': 38}) 
4039   
4040 -    def __delfield_sender(self): del self.__field_sender 
4041   
4042      sender=property(__getfield_sender, __setfield_sender, __delfield_sender, None) 
4043   
4044 -    def __getfield_unknown4(self): 
4045          return self.__field_unknown4.getvalue() 
4046   
4047 -    def __setfield_unknown4(self, value): 
4048          if isinstance(value,DATA): 
4049              self.__field_unknown4=value 
4050          else: 
4051              self.__field_unknown4=DATA(value,**{'sizeinbytes': 15}) 
4052   
4053 -    def __delfield_unknown4(self): del self.__field_unknown4 
4054   
4055      unknown4=property(__getfield_unknown4, __setfield_unknown4, __delfield_unknown4, None) 
4056   
4057 -    def __getfield_lg_time(self): 
4058          return self.__field_lg_time.getvalue() 
4059   
4060 -    def __setfield_lg_time(self, value): 
4061          if isinstance(value,LGCALDATE): 
4062              self.__field_lg_time=value 
4063          else: 
4064              self.__field_lg_time=LGCALDATE(value,**{'sizeinbytes': 4}) 
4065   
4066 -    def __delfield_lg_time(self): del self.__field_lg_time 
4067   
4068      lg_time=property(__getfield_lg_time, __setfield_lg_time, __delfield_lg_time, None) 
4069   
4070 -    def __getfield_GPStime(self): 
4071          return self.__field_GPStime.getvalue() 
4072   
4073 -    def __setfield_GPStime(self, value): 
4074          if isinstance(value,GPSDATE): 
4075              self.__field_GPStime=value 
4076          else: 
4077              self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4}) 
4078   
4079 -    def __delfield_GPStime(self): del self.__field_GPStime 
4080   
4081      GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None) 
4082   
4083 -    def __getfield_unknown41(self): 
4084          return self.__field_unknown41.getvalue() 
4085   
4086 -    def __setfield_unknown41(self, value): 
4087          if isinstance(value,UINT): 
4088              self.__field_unknown41=value 
4089          else: 
4090              self.__field_unknown41=UINT(value,**{'sizeinbytes': 2}) 
4091   
4092 -    def __delfield_unknown41(self): del self.__field_unknown41 
4093   
4094      unknown41=property(__getfield_unknown41, __setfield_unknown41, __delfield_unknown41, None) 
4095   
4096 -    def __getfield_read(self): 
4097          return self.__field_read.getvalue() 
4098   
4099 -    def __setfield_read(self, value): 
4100          if isinstance(value,UINT): 
4101              self.__field_read=value 
4102          else: 
4103              self.__field_read=UINT(value,**{'sizeinbytes': 2}) 
4104   
4105 -    def __delfield_read(self): del self.__field_read 
4106   
4107      read=property(__getfield_read, __setfield_read, __delfield_read, None) 
4108   
4109 -    def __getfield_unknown5(self): 
4110          return self.__field_unknown5.getvalue() 
4111   
4112 -    def __setfield_unknown5(self, value): 
4113          if isinstance(value,UINT): 
4114              self.__field_unknown5=value 
4115          else: 
4116              self.__field_unknown5=UINT(value,**{'sizeinbytes': 9}) 
4117   
4118 -    def __delfield_unknown5(self): del self.__field_unknown5 
4119   
4120      unknown5=property(__getfield_unknown5, __setfield_unknown5, __delfield_unknown5, None) 
4121   
4122 -    def __getfield_subject(self): 
4123          return self.__field_subject.getvalue() 
4124   
4125 -    def __setfield_subject(self, value): 
4126          if isinstance(value,USTRING): 
4127              self.__field_subject=value 
4128          else: 
4129              self.__field_subject=USTRING(value,**{'sizeinbytes': 21, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
4130   
4131 -    def __delfield_subject(self): del self.__field_subject 
4132   
4133      subject=property(__getfield_subject, __setfield_subject, __delfield_subject, None) 
4134   
4135 -    def __getfield_unknown6(self): 
4136          return self.__field_unknown6.getvalue() 
4137   
4138 -    def __setfield_unknown6(self, value): 
4139          if isinstance(value,UINT): 
4140              self.__field_unknown6=value 
4141          else: 
4142              self.__field_unknown6=UINT(value,**{'sizeinbytes': 8}) 
4143   
4144 -    def __delfield_unknown6(self): del self.__field_unknown6 
4145   
4146      unknown6=property(__getfield_unknown6, __setfield_unknown6, __delfield_unknown6, None) 
4147   
4148 -    def __getfield_msglength(self): 
4149          return self.__field_msglength.getvalue() 
4150   
4151 -    def __setfield_msglength(self, value): 
4152          if isinstance(value,UINT): 
4153              self.__field_msglength=value 
4154          else: 
4155              self.__field_msglength=UINT(value,**{'sizeinbytes': 2}) 
4156   
4157 -    def __delfield_msglength(self): del self.__field_msglength 
4158   
4159      msglength=property(__getfield_msglength, __setfield_msglength, __delfield_msglength, None) 
4160   
4161 -    def __getfield_unknown7(self): 
4162          return self.__field_unknown7.getvalue() 
4163   
4164 -    def __setfield_unknown7(self, value): 
4165          if isinstance(value,UINT): 
4166              self.__field_unknown7=value 
4167          else: 
4168              self.__field_unknown7=UINT(value,**{'sizeinbytes': 18}) 
4169   
4170 -    def __delfield_unknown7(self): del self.__field_unknown7 
4171   
4172      unknown7=property(__getfield_unknown7, __setfield_unknown7, __delfield_unknown7, None) 
4173   
4174 -    def __getfield_msg(self): 
4175          return self.__field_msg.getvalue() 
4176   
4177 -    def __setfield_msg(self, value): 
4178          if isinstance(value,USTRING): 
4179              self.__field_msg=value 
4180          else: 
4181              self.__field_msg=USTRING(value,**{'sizeinbytes': 200, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
4182   
4183 -    def __delfield_msg(self): del self.__field_msg 
4184   
4185      msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None) 
4186   
4187 -    def __getfield_unknown8(self): 
4188          return self.__field_unknown8.getvalue() 
4189   
4190 -    def __setfield_unknown8(self, value): 
4191          if isinstance(value,DATA): 
4192              self.__field_unknown8=value 
4193          else: 
4194              self.__field_unknown8=DATA(value,) 
4195   
4196 -    def __delfield_unknown8(self): del self.__field_unknown8 
4197   
4198      unknown8=property(__getfield_unknown8, __setfield_unknown8, __delfield_unknown8, None) 
4199   
4200 -    def iscontainer(self): 
4201          return True 
4202   
4203 -    def containerelements(self): 
4204          yield ('unknown1', self.__field_unknown1, None) 
4205          yield ('msg_index2', self.__field_msg_index2, None) 
4206          yield ('unknown2', self.__field_unknown2, None) 
4207          yield ('timesent', self.__field_timesent, None) 
4208          yield ('unknown', self.__field_unknown, None) 
4209          yield ('callback_length', self.__field_callback_length, None) 
4210          yield ('callback', self.__field_callback, None) 
4211          yield ('sender_length', self.__field_sender_length, None) 
4212          yield ('sender', self.__field_sender, None) 
4213          yield ('unknown4', self.__field_unknown4, None) 
4214          yield ('lg_time', self.__field_lg_time, None) 
4215          yield ('GPStime', self.__field_GPStime, None) 
4216          yield ('unknown41', self.__field_unknown41, None) 
4217          yield ('read', self.__field_read, None) 
4218          yield ('unknown5', self.__field_unknown5, None) 
4219          yield ('subject', self.__field_subject, None) 
4220          yield ('unknown6', self.__field_unknown6, None) 
4221          yield ('msglength', self.__field_msglength, None) 
4222          yield ('unknown7', self.__field_unknown7, None) 
4223          yield ('msg', self.__field_msg, None) 
4224          yield ('unknown8', self.__field_unknown8, None) 
4225   
4226   
4227   
4228   
4229 -class _gen_p_lglg6190_333(BaseProtogenClass): 
4230      'Anonymous inner class' 
4231      __fields=['byte'] 
4232   
4233 -    def __init__(self, *args, **kwargs): 
4234          dict={} 
4235          # What was supplied to this function 
4236          dict.update(kwargs) 
4237          # Parent constructor 
4238          super(_gen_p_lglg6190_333,self).__init__(**dict) 
4239          if self.__class__ is _gen_p_lglg6190_333: 
4240              self._update(args,dict) 
4241   
4242   
4243 -    def getfields(self): 
4244          return self.__fields 
4245   
4246   
4247 -    def _update(self, args, kwargs): 
4248          super(_gen_p_lglg6190_333,self)._update(args,kwargs) 
4249          keys=kwargs.keys() 
4250          for key in keys: 
4251              if key in self.__fields: 
4252                  setattr(self, key, kwargs[key]) 
4253                  del kwargs[key] 
4254          # Were any unrecognized kwargs passed in? 
4255          if __debug__: 
4256              self._complainaboutunusedargs(_gen_p_lglg6190_333,kwargs) 
4257          if len(args): 
4258              dict2={'sizeinbytes': 1} 
4259              dict2.update(kwargs) 
4260              kwargs=dict2 
4261              self.__field_byte=UINT(*args,**dict2) 
4262          # Make all P fields that haven't already been constructed 
4263   
4264   
4265 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
4266          'Writes this packet to the supplied buffer' 
4267          self._bufferstartoffset=buf.getcurrentoffset() 
4268          self.__field_byte.writetobuffer(buf) 
4269          self._bufferendoffset=buf.getcurrentoffset() 
4270          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
4271   
4272   
4273 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
4274          'Reads this packet from the supplied buffer' 
4275          self._bufferstartoffset=buf.getcurrentoffset() 
4276          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
4277          self.__field_byte=UINT(**{'sizeinbytes': 1}) 
4278          self.__field_byte.readfrombuffer(buf) 
4279          self._bufferendoffset=buf.getcurrentoffset() 
4280   
4281   
4282 -    def __getfield_byte(self): 
4283          return self.__field_byte.getvalue() 
4284   
4285 -    def __setfield_byte(self, value): 
4286          if isinstance(value,UINT): 
4287              self.__field_byte=value 
4288          else: 
4289              self.__field_byte=UINT(value,**{'sizeinbytes': 1}) 
4290   
4291 -    def __delfield_byte(self): del self.__field_byte 
4292   
4293      byte=property(__getfield_byte, __setfield_byte, __delfield_byte, "individual byte of senders phone number") 
4294   
4295 -    def iscontainer(self): 
4296          return True 
4297   
4298 -    def containerelements(self): 
4299          yield ('byte', self.__field_byte, "individual byte of senders phone number") 
4300   
4301   
4302   
4303   
4304 -class sms_quick_text(BaseProtogenClass): 
4305      __fields=['msgs'] 
4306   
4307 -    def __init__(self, *args, **kwargs): 
4308          dict={} 
4309          # What was supplied to this function 
4310          dict.update(kwargs) 
4311          # Parent constructor 
4312          super(sms_quick_text,self).__init__(**dict) 
4313          if self.__class__ is sms_quick_text: 
4314              self._update(args,dict) 
4315   
4316   
4317 -    def getfields(self): 
4318          return self.__fields 
4319   
4320   
4321 -    def _update(self, args, kwargs): 
4322          super(sms_quick_text,self)._update(args,kwargs) 
4323          keys=kwargs.keys() 
4324          for key in keys: 
4325              if key in self.__fields: 
4326                  setattr(self, key, kwargs[key]) 
4327                  del kwargs[key] 
4328          # Were any unrecognized kwargs passed in? 
4329          if __debug__: 
4330              self._complainaboutunusedargs(sms_quick_text,kwargs) 
4331          if len(args): 
4332              dict2={'elementclass': _gen_p_lglg6190_354, } 
4333              dict2.update(kwargs) 
4334              kwargs=dict2 
4335              self.__field_msgs=LIST(*args,**dict2) 
4336          # Make all P fields that haven't already been constructed 
4337   
4338   
4339 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
4340          'Writes this packet to the supplied buffer' 
4341          self._bufferstartoffset=buf.getcurrentoffset() 
4342          try: self.__field_msgs 
4343          except: 
4344              self.__field_msgs=LIST(**{'elementclass': _gen_p_lglg6190_354, }) 
4345          self.__field_msgs.writetobuffer(buf) 
4346          self._bufferendoffset=buf.getcurrentoffset() 
4347          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
4348   
4349   
4350 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
4351          'Reads this packet from the supplied buffer' 
4352          self._bufferstartoffset=buf.getcurrentoffset() 
4353          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
4354          self.__field_msgs=LIST(**{'elementclass': _gen_p_lglg6190_354, }) 
4355          self.__field_msgs.readfrombuffer(buf) 
4356          self._bufferendoffset=buf.getcurrentoffset() 
4357   
4358   
4359 -    def __getfield_msgs(self): 
4360          try: self.__field_msgs 
4361          except: 
4362              self.__field_msgs=LIST(**{'elementclass': _gen_p_lglg6190_354, }) 
4363          return self.__field_msgs.getvalue() 
4364   
4365 -    def __setfield_msgs(self, value): 
4366          if isinstance(value,LIST): 
4367              self.__field_msgs=value 
4368          else: 
4369              self.__field_msgs=LIST(value,**{'elementclass': _gen_p_lglg6190_354, }) 
4370   
4371 -    def __delfield_msgs(self): del self.__field_msgs 
4372   
4373      msgs=property(__getfield_msgs, __setfield_msgs, __delfield_msgs, None) 
4374   
4375 -    def iscontainer(self): 
4376          return True 
4377   
4378 -    def containerelements(self): 
4379          yield ('msgs', self.__field_msgs, None) 
4380   
4381   
4382   
4383   
4384 -class _gen_p_lglg6190_354(BaseProtogenClass): 
4385      'Anonymous inner class' 
4386      __fields=['msg'] 
4387   
4388 -    def __init__(self, *args, **kwargs): 
4389          dict={} 
4390          # What was supplied to this function 
4391          dict.update(kwargs) 
4392          # Parent constructor 
4393          super(_gen_p_lglg6190_354,self).__init__(**dict) 
4394          if self.__class__ is _gen_p_lglg6190_354: 
4395              self._update(args,dict) 
4396   
4397   
4398 -    def getfields(self): 
4399          return self.__fields 
4400   
4401   
4402 -    def _update(self, args, kwargs): 
4403          super(_gen_p_lglg6190_354,self)._update(args,kwargs) 
4404          keys=kwargs.keys() 
4405          for key in keys: 
4406              if key in self.__fields: 
4407                  setattr(self, key, kwargs[key]) 
4408                  del kwargs[key] 
4409          # Were any unrecognized kwargs passed in? 
4410          if __debug__: 
4411              self._complainaboutunusedargs(_gen_p_lglg6190_354,kwargs) 
4412          if len(args): 
4413              dict2={'encoding': PHONE_ENCODING} 
4414              dict2.update(kwargs) 
4415              kwargs=dict2 
4416              self.__field_msg=USTRING(*args,**dict2) 
4417          # Make all P fields that haven't already been constructed 
4418   
4419   
4420 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
4421          'Writes this packet to the supplied buffer' 
4422          self._bufferstartoffset=buf.getcurrentoffset() 
4423          self.__field_msg.writetobuffer(buf) 
4424          self._bufferendoffset=buf.getcurrentoffset() 
4425          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
4426   
4427   
4428 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
4429          'Reads this packet from the supplied buffer' 
4430          self._bufferstartoffset=buf.getcurrentoffset() 
4431          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
4432          self.__field_msg=USTRING(**{'encoding': PHONE_ENCODING}) 
4433          self.__field_msg.readfrombuffer(buf) 
4434          self._bufferendoffset=buf.getcurrentoffset() 
4435   
4436   
4437 -    def __getfield_msg(self): 
4438          return self.__field_msg.getvalue() 
4439   
4440 -    def __setfield_msg(self, value): 
4441          if isinstance(value,USTRING): 
4442              self.__field_msg=value 
4443          else: 
4444              self.__field_msg=USTRING(value,**{'encoding': PHONE_ENCODING}) 
4445   
4446 -    def __delfield_msg(self): del self.__field_msg 
4447   
4448      msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None) 
4449   
4450 -    def iscontainer(self): 
4451          return True 
4452   
4453 -    def containerelements(self): 
4454          yield ('msg', self.__field_msg, None) 
4455