Source Code for Module phones.p_lgvx3200

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