Source Code for Module phones.p_lgvx7000

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