Source Code for Module phones.p_lgvi125

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