Source Code for Module phones.p_lgpm225

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