Source Code for Module phones.p_lgpm325

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