Source Code for Module phones.p_lglx260

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