Source Code for Module phones.p_lgvx4400

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