Source Code for Module phones.p_lglx570

   1  # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE 
   2   
   3  """Various descriptions of data specific to LG LX570 (Musiq)""" 
   4   
   5  import re 
   6   
   7  from prototypes import * 
   8  from prototypeslg import * 
   9   
  10  # Make all lg stuff available in this module as well 
  11  from p_lgvx4400 import * 
  12   
  13   
  14  # We use LSB for all integer like fields 
  15  UINT=UINTlsb 
  16  BOOL=BOOLlsb 
  17   
  18  MEMOLENGTH=33 
  19  NUMEMAILS=3 
  20  NUMPHONENUMBERS=5 
  21  NUMSPEEDDIALS=100 
  22  FIRSTSPEEDDIAL=1 
  23  LASTSPEEDDIAL=99 
  24  SPEEDDIALINDEX=0 
  25   
  26  numbertypetab=( 'cell', 'home', 'office', 'fax', 'pager', 'none' ) 
  27   
  28  PB_FILENAME='DB/SysDB/vCardSchema.vol' 
  29  RT_MC_INDEX_FILENAME='setas/mcRingerIndex.map' 
  30  RT_VM_INDEX_FILENAME='setas/voicememoRingerIndex.map' 
  31  RT_MC_PATH='melodyComposer' 
  32  RT_VM_PATH='VoiceDB/All/Memos' 
  33   
  34  SMS_CANNED_MAX_ITEMS=40 
  35  SMS_CANNED_MAX_LENGTH=101 
  36  SMS_CANNED_FILENAME="sms/canned_msg.dat" 
  37  SMS_PATTERNS={'Inbox': re.compile(r"^.*/inbox[0-9][0-9][0-9]\.dat$"), 
  38               'Sent': re.compile(r"^.*/outbox[0-9][0-9][0-9]\.dat$"), 
  39               } 
  40   
  41 -class indexentry(BaseProtogenClass): 
  42      __fields=['index', 'mediatype', 'name'] 
  43   
  44 -    def __init__(self, *args, **kwargs): 
  45          dict={} 
  46          # What was supplied to this function 
  47          dict.update(kwargs) 
  48          # Parent constructor 
  49          super(indexentry,self).__init__(**dict) 
  50          if self.__class__ is indexentry: 
  51              self._update(args,dict) 
  52   
  53   
  54 -    def getfields(self): 
  55          return self.__fields 
  56   
  57   
  58 -    def _update(self, args, kwargs): 
  59          super(indexentry,self)._update(args,kwargs) 
  60          keys=kwargs.keys() 
  61          for key in keys: 
  62              if key in self.__fields: 
  63                  setattr(self, key, kwargs[key]) 
  64                  del kwargs[key] 
  65          # Were any unrecognized kwargs passed in? 
  66          if __debug__: 
  67              self._complainaboutunusedargs(indexentry,kwargs) 
  68          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
  69          # Make all P fields that haven't already been constructed 
  70   
  71   
  72 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
  73          'Writes this packet to the supplied buffer' 
  74          self._bufferstartoffset=buf.getcurrentoffset() 
  75          self.__field_index.writetobuffer(buf) 
  76          self.__field_mediatype.writetobuffer(buf) 
  77          try: self.__field_name 
  78          except: 
  79              self.__field_name=USTRING(**{'sizeinbytes': 40, 'default': ""}) 
  80          self.__field_name.writetobuffer(buf) 
  81          self._bufferendoffset=buf.getcurrentoffset() 
  82          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
  83   
  84   
  85 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
  86          'Reads this packet from the supplied buffer' 
  87          self._bufferstartoffset=buf.getcurrentoffset() 
  88          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
  89          self.__field_index=UINT(**{'sizeinbytes': 1}) 
  90          self.__field_index.readfrombuffer(buf) 
  91          self.__field_mediatype=UINT(**{'sizeinbytes': 1}) 
  92          self.__field_mediatype.readfrombuffer(buf) 
  93          self.__field_name=USTRING(**{'sizeinbytes': 40, 'default': ""}) 
  94          self.__field_name.readfrombuffer(buf) 
  95          self._bufferendoffset=buf.getcurrentoffset() 
  96   
  97   
  98 -    def __getfield_index(self): 
  99          return self.__field_index.getvalue() 
 100   
 101 -    def __setfield_index(self, value): 
 102          if isinstance(value,UINT): 
 103              self.__field_index=value 
 104          else: 
 105              self.__field_index=UINT(value,**{'sizeinbytes': 1}) 
 106   
 107 -    def __delfield_index(self): del self.__field_index 
 108   
 109      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
 110   
 111 -    def __getfield_mediatype(self): 
 112          return self.__field_mediatype.getvalue() 
 113   
 114 -    def __setfield_mediatype(self, value): 
 115          if isinstance(value,UINT): 
 116              self.__field_mediatype=value 
 117          else: 
 118              self.__field_mediatype=UINT(value,**{'sizeinbytes': 1}) 
 119   
 120 -    def __delfield_mediatype(self): del self.__field_mediatype 
 121   
 122      mediatype=property(__getfield_mediatype, __setfield_mediatype, __delfield_mediatype, None) 
 123   
 124 -    def __getfield_name(self): 
 125          try: self.__field_name 
 126          except: 
 127              self.__field_name=USTRING(**{'sizeinbytes': 40, 'default': ""}) 
 128          return self.__field_name.getvalue() 
 129   
 130 -    def __setfield_name(self, value): 
 131          if isinstance(value,USTRING): 
 132              self.__field_name=value 
 133          else: 
 134              self.__field_name=USTRING(value,**{'sizeinbytes': 40, 'default': ""}) 
 135   
 136 -    def __delfield_name(self): del self.__field_name 
 137   
 138      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
 139   
 140 -    def iscontainer(self): 
 141          return True 
 142   
 143 -    def containerelements(self): 
 144          yield ('index', self.__field_index, None) 
 145          yield ('mediatype', self.__field_mediatype, None) 
 146          yield ('name', self.__field_name, None) 
 147   
 148   
 149   
 150   
 151 -class indexfile(BaseProtogenClass): 
 152      "Used for tracking wallpaper and ringtones" 
 153      __fields=['numactiveitems', 'items'] 
 154   
 155 -    def __init__(self, *args, **kwargs): 
 156          dict={} 
 157          # What was supplied to this function 
 158          dict.update(kwargs) 
 159          # Parent constructor 
 160          super(indexfile,self).__init__(**dict) 
 161          if self.__class__ is indexfile: 
 162              self._update(args,dict) 
 163   
 164   
 165 -    def getfields(self): 
 166          return self.__fields 
 167   
 168   
 169 -    def _update(self, args, kwargs): 
 170          super(indexfile,self)._update(args,kwargs) 
 171          keys=kwargs.keys() 
 172          for key in keys: 
 173              if key in self.__fields: 
 174                  setattr(self, key, kwargs[key]) 
 175                  del kwargs[key] 
 176          # Were any unrecognized kwargs passed in? 
 177          if __debug__: 
 178              self._complainaboutunusedargs(indexfile,kwargs) 
 179          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 180          # Make all P fields that haven't already been constructed 
 181   
 182   
 183 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 184          'Writes this packet to the supplied buffer' 
 185          self._bufferstartoffset=buf.getcurrentoffset() 
 186          self.__field_numactiveitems.writetobuffer(buf) 
 187          try: self.__field_items 
 188          except: 
 189              self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True}) 
 190          self.__field_items.writetobuffer(buf) 
 191          self._bufferendoffset=buf.getcurrentoffset() 
 192          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 193   
 194   
 195 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 196          'Reads this packet from the supplied buffer' 
 197          self._bufferstartoffset=buf.getcurrentoffset() 
 198          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 199          self.__field_numactiveitems=UINT(**{'sizeinbytes': 2}) 
 200          self.__field_numactiveitems.readfrombuffer(buf) 
 201          self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True}) 
 202          self.__field_items.readfrombuffer(buf) 
 203          self._bufferendoffset=buf.getcurrentoffset() 
 204   
 205   
 206 -    def __getfield_numactiveitems(self): 
 207          return self.__field_numactiveitems.getvalue() 
 208   
 209 -    def __setfield_numactiveitems(self, value): 
 210          if isinstance(value,UINT): 
 211              self.__field_numactiveitems=value 
 212          else: 
 213              self.__field_numactiveitems=UINT(value,**{'sizeinbytes': 2}) 
 214   
 215 -    def __delfield_numactiveitems(self): del self.__field_numactiveitems 
 216   
 217      numactiveitems=property(__getfield_numactiveitems, __setfield_numactiveitems, __delfield_numactiveitems, None) 
 218   
 219 -    def __getfield_items(self): 
 220          try: self.__field_items 
 221          except: 
 222              self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True}) 
 223          return self.__field_items.getvalue() 
 224   
 225 -    def __setfield_items(self, value): 
 226          if isinstance(value,LIST): 
 227              self.__field_items=value 
 228          else: 
 229              self.__field_items=LIST(value,**{'elementclass': indexentry, 'createdefault': True}) 
 230   
 231 -    def __delfield_items(self): del self.__field_items 
 232   
 233      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
 234   
 235 -    def iscontainer(self): 
 236          return True 
 237   
 238 -    def containerelements(self): 
 239          yield ('numactiveitems', self.__field_numactiveitems, None) 
 240          yield ('items', self.__field_items, None) 
 241   
 242   
 243   
 244   
 245 -class pbreadentryresponse(BaseProtogenClass): 
 246      "Results of reading one entry" 
 247      __fields=['header', 'entry'] 
 248   
 249 -    def __init__(self, *args, **kwargs): 
 250          dict={} 
 251          # What was supplied to this function 
 252          dict.update(kwargs) 
 253          # Parent constructor 
 254          super(pbreadentryresponse,self).__init__(**dict) 
 255          if self.__class__ is pbreadentryresponse: 
 256              self._update(args,dict) 
 257   
 258   
 259 -    def getfields(self): 
 260          return self.__fields 
 261   
 262   
 263 -    def _update(self, args, kwargs): 
 264          super(pbreadentryresponse,self)._update(args,kwargs) 
 265          keys=kwargs.keys() 
 266          for key in keys: 
 267              if key in self.__fields: 
 268                  setattr(self, key, kwargs[key]) 
 269                  del kwargs[key] 
 270          # Were any unrecognized kwargs passed in? 
 271          if __debug__: 
 272              self._complainaboutunusedargs(pbreadentryresponse,kwargs) 
 273          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 274          # Make all P fields that haven't already been constructed 
 275   
 276   
 277 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 278          'Writes this packet to the supplied buffer' 
 279          self._bufferstartoffset=buf.getcurrentoffset() 
 280          self.__field_header.writetobuffer(buf) 
 281          self.__field_entry.writetobuffer(buf) 
 282          self._bufferendoffset=buf.getcurrentoffset() 
 283          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 284   
 285   
 286 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 287          'Reads this packet from the supplied buffer' 
 288          self._bufferstartoffset=buf.getcurrentoffset() 
 289          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 290          self.__field_header=pbheader() 
 291          self.__field_header.readfrombuffer(buf) 
 292          self.__field_entry=pbentry() 
 293          self.__field_entry.readfrombuffer(buf) 
 294          self._bufferendoffset=buf.getcurrentoffset() 
 295   
 296   
 297 -    def __getfield_header(self): 
 298          return self.__field_header.getvalue() 
 299   
 300 -    def __setfield_header(self, value): 
 301          if isinstance(value,pbheader): 
 302              self.__field_header=value 
 303          else: 
 304              self.__field_header=pbheader(value,) 
 305   
 306 -    def __delfield_header(self): del self.__field_header 
 307   
 308      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
 309   
 310 -    def __getfield_entry(self): 
 311          return self.__field_entry.getvalue() 
 312   
 313 -    def __setfield_entry(self, value): 
 314          if isinstance(value,pbentry): 
 315              self.__field_entry=value 
 316          else: 
 317              self.__field_entry=pbentry(value,) 
 318   
 319 -    def __delfield_entry(self): del self.__field_entry 
 320   
 321      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
 322   
 323 -    def iscontainer(self): 
 324          return True 
 325   
 326 -    def containerelements(self): 
 327          yield ('header', self.__field_header, None) 
 328          yield ('entry', self.__field_entry, None) 
 329   
 330   
 331   
 332   
 333 -class pbupdateentryrequest(BaseProtogenClass): 
 334      __fields=['header', 'entry'] 
 335   
 336 -    def __init__(self, *args, **kwargs): 
 337          dict={} 
 338          # What was supplied to this function 
 339          dict.update(kwargs) 
 340          # Parent constructor 
 341          super(pbupdateentryrequest,self).__init__(**dict) 
 342          if self.__class__ is pbupdateentryrequest: 
 343              self._update(args,dict) 
 344   
 345   
 346 -    def getfields(self): 
 347          return self.__fields 
 348   
 349   
 350 -    def _update(self, args, kwargs): 
 351          super(pbupdateentryrequest,self)._update(args,kwargs) 
 352          keys=kwargs.keys() 
 353          for key in keys: 
 354              if key in self.__fields: 
 355                  setattr(self, key, kwargs[key]) 
 356                  del kwargs[key] 
 357          # Were any unrecognized kwargs passed in? 
 358          if __debug__: 
 359              self._complainaboutunusedargs(pbupdateentryrequest,kwargs) 
 360          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 361          # Make all P fields that haven't already been constructed 
 362   
 363   
 364 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 365          'Writes this packet to the supplied buffer' 
 366          self._bufferstartoffset=buf.getcurrentoffset() 
 367          try: self.__field_header 
 368          except: 
 369              self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01}) 
 370          self.__field_header.writetobuffer(buf) 
 371          self.__field_entry.writetobuffer(buf) 
 372          self._bufferendoffset=buf.getcurrentoffset() 
 373          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 374   
 375   
 376 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 377          'Reads this packet from the supplied buffer' 
 378          self._bufferstartoffset=buf.getcurrentoffset() 
 379          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 380          self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01}) 
 381          self.__field_header.readfrombuffer(buf) 
 382          self.__field_entry=pbentry() 
 383          self.__field_entry.readfrombuffer(buf) 
 384          self._bufferendoffset=buf.getcurrentoffset() 
 385   
 386   
 387 -    def __getfield_header(self): 
 388          try: self.__field_header 
 389          except: 
 390              self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01}) 
 391          return self.__field_header.getvalue() 
 392   
 393 -    def __setfield_header(self, value): 
 394          if isinstance(value,pbheader): 
 395              self.__field_header=value 
 396          else: 
 397              self.__field_header=pbheader(value,**{'command': 0x04, 'flag': 0x01}) 
 398   
 399 -    def __delfield_header(self): del self.__field_header 
 400   
 401      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
 402   
 403 -    def __getfield_entry(self): 
 404          return self.__field_entry.getvalue() 
 405   
 406 -    def __setfield_entry(self, value): 
 407          if isinstance(value,pbentry): 
 408              self.__field_entry=value 
 409          else: 
 410              self.__field_entry=pbentry(value,) 
 411   
 412 -    def __delfield_entry(self): del self.__field_entry 
 413   
 414      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
 415   
 416 -    def iscontainer(self): 
 417          return True 
 418   
 419 -    def containerelements(self): 
 420          yield ('header', self.__field_header, None) 
 421          yield ('entry', self.__field_entry, None) 
 422   
 423   
 424   
 425   
 426 -class pbappendentryrequest(BaseProtogenClass): 
 427      __fields=['header', 'entry'] 
 428   
 429 -    def __init__(self, *args, **kwargs): 
 430          dict={} 
 431          # What was supplied to this function 
 432          dict.update(kwargs) 
 433          # Parent constructor 
 434          super(pbappendentryrequest,self).__init__(**dict) 
 435          if self.__class__ is pbappendentryrequest: 
 436              self._update(args,dict) 
 437   
 438   
 439 -    def getfields(self): 
 440          return self.__fields 
 441   
 442   
 443 -    def _update(self, args, kwargs): 
 444          super(pbappendentryrequest,self)._update(args,kwargs) 
 445          keys=kwargs.keys() 
 446          for key in keys: 
 447              if key in self.__fields: 
 448                  setattr(self, key, kwargs[key]) 
 449                  del kwargs[key] 
 450          # Were any unrecognized kwargs passed in? 
 451          if __debug__: 
 452              self._complainaboutunusedargs(pbappendentryrequest,kwargs) 
 453          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 454          # Make all P fields that haven't already been constructed 
 455   
 456   
 457 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 458          'Writes this packet to the supplied buffer' 
 459          self._bufferstartoffset=buf.getcurrentoffset() 
 460          try: self.__field_header 
 461          except: 
 462              self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01}) 
 463          self.__field_header.writetobuffer(buf) 
 464          self.__field_entry.writetobuffer(buf) 
 465          self._bufferendoffset=buf.getcurrentoffset() 
 466          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 467   
 468   
 469 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 470          'Reads this packet from the supplied buffer' 
 471          self._bufferstartoffset=buf.getcurrentoffset() 
 472          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 473          self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01}) 
 474          self.__field_header.readfrombuffer(buf) 
 475          self.__field_entry=pbentry() 
 476          self.__field_entry.readfrombuffer(buf) 
 477          self._bufferendoffset=buf.getcurrentoffset() 
 478   
 479   
 480 -    def __getfield_header(self): 
 481          try: self.__field_header 
 482          except: 
 483              self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01}) 
 484          return self.__field_header.getvalue() 
 485   
 486 -    def __setfield_header(self, value): 
 487          if isinstance(value,pbheader): 
 488              self.__field_header=value 
 489          else: 
 490              self.__field_header=pbheader(value,**{'command': 0x03, 'flag': 0x01}) 
 491   
 492 -    def __delfield_header(self): del self.__field_header 
 493   
 494      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
 495   
 496 -    def __getfield_entry(self): 
 497          return self.__field_entry.getvalue() 
 498   
 499 -    def __setfield_entry(self, value): 
 500          if isinstance(value,pbentry): 
 501              self.__field_entry=value 
 502          else: 
 503              self.__field_entry=pbentry(value,) 
 504   
 505 -    def __delfield_entry(self): del self.__field_entry 
 506   
 507      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
 508   
 509 -    def iscontainer(self): 
 510          return True 
 511   
 512 -    def containerelements(self): 
 513          yield ('header', self.__field_header, None) 
 514          yield ('entry', self.__field_entry, None) 
 515   
 516   
 517   
 518   
 519 -class pbentry(BaseProtogenClass): 
 520      __fields=['serial1', 'entrysize', 'serial2', 'entrynumber', 'name', 'group', 'dunno1', 'ringtone', 'dunno2', 'memo', 'emails', 'url', 'speeddials', 'numbertypes', 'numbers', 'dunno3', 'wallpaper'] 
 521   
 522 -    def __init__(self, *args, **kwargs): 
 523          dict={} 
 524          # What was supplied to this function 
 525          dict.update(kwargs) 
 526          # Parent constructor 
 527          super(pbentry,self).__init__(**dict) 
 528          if self.__class__ is pbentry: 
 529              self._update(args,dict) 
 530   
 531   
 532 -    def getfields(self): 
 533          return self.__fields 
 534   
 535   
 536 -    def _update(self, args, kwargs): 
 537          super(pbentry,self)._update(args,kwargs) 
 538          keys=kwargs.keys() 
 539          for key in keys: 
 540              if key in self.__fields: 
 541                  setattr(self, key, kwargs[key]) 
 542                  del kwargs[key] 
 543          # Were any unrecognized kwargs passed in? 
 544          if __debug__: 
 545              self._complainaboutunusedargs(pbentry,kwargs) 
 546          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 547          # Make all P fields that haven't already been constructed 
 548          try: self.__field_wallpaper 
 549          except: 
 550              self.__field_wallpaper=UINT(**{ 'default': 0 }) 
 551   
 552   
 553 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 554          'Writes this packet to the supplied buffer' 
 555          self._bufferstartoffset=buf.getcurrentoffset() 
 556          self.__field_serial1.writetobuffer(buf) 
 557          try: self.__field_entrysize 
 558          except: 
 559              self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0x029E}) 
 560          self.__field_entrysize.writetobuffer(buf) 
 561          self.__field_serial2.writetobuffer(buf) 
 562          self.__field_entrynumber.writetobuffer(buf) 
 563          self.__field_name.writetobuffer(buf) 
 564          self.__field_group.writetobuffer(buf) 
 565          try: self.__field_dunno1 
 566          except: 
 567              self.__field_dunno1=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
 568          self.__field_dunno1.writetobuffer(buf) 
 569          self.__field_ringtone.writetobuffer(buf) 
 570          try: self.__field_dunno2 
 571          except: 
 572              self.__field_dunno2=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
 573          self.__field_dunno2.writetobuffer(buf) 
 574          self.__field_memo.writetobuffer(buf) 
 575          try: self.__field_emails 
 576          except: 
 577              self.__field_emails=LIST(**{'elementclass': _gen_p_lglx570_100, 'length': NUMEMAILS}) 
 578          self.__field_emails.writetobuffer(buf) 
 579          self.__field_url.writetobuffer(buf) 
 580          try: self.__field_speeddials 
 581          except: 
 582              self.__field_speeddials=LIST(**{'elementclass': _gen_p_lglx570_103,  'length': NUMPHONENUMBERS }) 
 583          self.__field_speeddials.writetobuffer(buf) 
 584          try: self.__field_numbertypes 
 585          except: 
 586              self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lglx570_105, 'length': NUMPHONENUMBERS}) 
 587          self.__field_numbertypes.writetobuffer(buf) 
 588          try: self.__field_numbers 
 589          except: 
 590              self.__field_numbers=LIST(**{'elementclass': _gen_p_lglx570_107, 'length': NUMPHONENUMBERS}) 
 591          self.__field_numbers.writetobuffer(buf) 
 592          try: self.__field_dunno3 
 593          except: 
 594              self.__field_dunno3=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
 595          self.__field_dunno3.writetobuffer(buf) 
 596          self._bufferendoffset=buf.getcurrentoffset() 
 597          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 598   
 599   
 600 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 601          'Reads this packet from the supplied buffer' 
 602          self._bufferstartoffset=buf.getcurrentoffset() 
 603          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 604          self.__field_serial1=UINT(**{'sizeinbytes': 4}) 
 605          self.__field_serial1.readfrombuffer(buf) 
 606          self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0x029E}) 
 607          self.__field_entrysize.readfrombuffer(buf) 
 608          self.__field_serial2=UINT(**{'sizeinbytes': 4}) 
 609          self.__field_serial2.readfrombuffer(buf) 
 610          self.__field_entrynumber=UINT(**{'sizeinbytes': 4}) 
 611          self.__field_entrynumber.readfrombuffer(buf) 
 612          self.__field_name=USTRING(**{'sizeinbytes': 73, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
 613          self.__field_name.readfrombuffer(buf) 
 614          self.__field_group=UINT(**{'sizeinbytes': 2}) 
 615          self.__field_group.readfrombuffer(buf) 
 616          self.__field_dunno1=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
 617          self.__field_dunno1.readfrombuffer(buf) 
 618          self.__field_ringtone=UINT(**{'sizeinbytes': 2}) 
 619          self.__field_ringtone.readfrombuffer(buf) 
 620          self.__field_dunno2=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
 621          self.__field_dunno2.readfrombuffer(buf) 
 622          self.__field_memo=USTRING(**{'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'sizeinbytes': MEMOLENGTH}) 
 623          self.__field_memo.readfrombuffer(buf) 
 624          self.__field_emails=LIST(**{'elementclass': _gen_p_lglx570_100, 'length': NUMEMAILS}) 
 625          self.__field_emails.readfrombuffer(buf) 
 626          self.__field_url=USTRING(**{'sizeinbytes': 73, 'raiseonunterminatedread': False}) 
 627          self.__field_url.readfrombuffer(buf) 
 628          self.__field_speeddials=LIST(**{'elementclass': _gen_p_lglx570_103,  'length': NUMPHONENUMBERS }) 
 629          self.__field_speeddials.readfrombuffer(buf) 
 630          self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lglx570_105, 'length': NUMPHONENUMBERS}) 
 631          self.__field_numbertypes.readfrombuffer(buf) 
 632          self.__field_numbers=LIST(**{'elementclass': _gen_p_lglx570_107, 'length': NUMPHONENUMBERS}) 
 633          self.__field_numbers.readfrombuffer(buf) 
 634          self.__field_dunno3=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
 635          self.__field_dunno3.readfrombuffer(buf) 
 636          self._bufferendoffset=buf.getcurrentoffset() 
 637   
 638   
 639 -    def __getfield_serial1(self): 
 640          return self.__field_serial1.getvalue() 
 641   
 642 -    def __setfield_serial1(self, value): 
 643          if isinstance(value,UINT): 
 644              self.__field_serial1=value 
 645          else: 
 646              self.__field_serial1=UINT(value,**{'sizeinbytes': 4}) 
 647   
 648 -    def __delfield_serial1(self): del self.__field_serial1 
 649   
 650      serial1=property(__getfield_serial1, __setfield_serial1, __delfield_serial1, None) 
 651   
 652 -    def __getfield_entrysize(self): 
 653          try: self.__field_entrysize 
 654          except: 
 655              self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0x029E}) 
 656          return self.__field_entrysize.getvalue() 
 657   
 658 -    def __setfield_entrysize(self, value): 
 659          if isinstance(value,UINT): 
 660              self.__field_entrysize=value 
 661          else: 
 662              self.__field_entrysize=UINT(value,**{'sizeinbytes': 2, 'constant': 0x029E}) 
 663   
 664 -    def __delfield_entrysize(self): del self.__field_entrysize 
 665   
 666      entrysize=property(__getfield_entrysize, __setfield_entrysize, __delfield_entrysize, None) 
 667   
 668 -    def __getfield_serial2(self): 
 669          return self.__field_serial2.getvalue() 
 670   
 671 -    def __setfield_serial2(self, value): 
 672          if isinstance(value,UINT): 
 673              self.__field_serial2=value 
 674          else: 
 675              self.__field_serial2=UINT(value,**{'sizeinbytes': 4}) 
 676   
 677 -    def __delfield_serial2(self): del self.__field_serial2 
 678   
 679      serial2=property(__getfield_serial2, __setfield_serial2, __delfield_serial2, None) 
 680   
 681 -    def __getfield_entrynumber(self): 
 682          return self.__field_entrynumber.getvalue() 
 683   
 684 -    def __setfield_entrynumber(self, value): 
 685          if isinstance(value,UINT): 
 686              self.__field_entrynumber=value 
 687          else: 
 688              self.__field_entrynumber=UINT(value,**{'sizeinbytes': 4}) 
 689   
 690 -    def __delfield_entrynumber(self): del self.__field_entrynumber 
 691   
 692      entrynumber=property(__getfield_entrynumber, __setfield_entrynumber, __delfield_entrynumber, None) 
 693   
 694 -    def __getfield_name(self): 
 695          return self.__field_name.getvalue() 
 696   
 697 -    def __setfield_name(self, value): 
 698          if isinstance(value,USTRING): 
 699              self.__field_name=value 
 700          else: 
 701              self.__field_name=USTRING(value,**{'sizeinbytes': 73, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
 702   
 703 -    def __delfield_name(self): del self.__field_name 
 704   
 705      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
 706   
 707 -    def __getfield_group(self): 
 708          return self.__field_group.getvalue() 
 709   
 710 -    def __setfield_group(self, value): 
 711          if isinstance(value,UINT): 
 712              self.__field_group=value 
 713          else: 
 714              self.__field_group=UINT(value,**{'sizeinbytes': 2}) 
 715   
 716 -    def __delfield_group(self): del self.__field_group 
 717   
 718      group=property(__getfield_group, __setfield_group, __delfield_group, None) 
 719   
 720 -    def __getfield_dunno1(self): 
 721          try: self.__field_dunno1 
 722          except: 
 723              self.__field_dunno1=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
 724          return self.__field_dunno1.getvalue() 
 725   
 726 -    def __setfield_dunno1(self, value): 
 727          if isinstance(value,UINT): 
 728              self.__field_dunno1=value 
 729          else: 
 730              self.__field_dunno1=UINT(value,**{'sizeinbytes': 1,  'default': 0 }) 
 731   
 732 -    def __delfield_dunno1(self): del self.__field_dunno1 
 733   
 734      dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None) 
 735   
 736 -    def __getfield_ringtone(self): 
 737          return self.__field_ringtone.getvalue() 
 738   
 739 -    def __setfield_ringtone(self, value): 
 740          if isinstance(value,UINT): 
 741              self.__field_ringtone=value 
 742          else: 
 743              self.__field_ringtone=UINT(value,**{'sizeinbytes': 2}) 
 744   
 745 -    def __delfield_ringtone(self): del self.__field_ringtone 
 746   
 747      ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 
 748   
 749 -    def __getfield_dunno2(self): 
 750          try: self.__field_dunno2 
 751          except: 
 752              self.__field_dunno2=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
 753          return self.__field_dunno2.getvalue() 
 754   
 755 -    def __setfield_dunno2(self, value): 
 756          if isinstance(value,UINT): 
 757              self.__field_dunno2=value 
 758          else: 
 759              self.__field_dunno2=UINT(value,**{'sizeinbytes': 2,  'default': 0 }) 
 760   
 761 -    def __delfield_dunno2(self): del self.__field_dunno2 
 762   
 763      dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None) 
 764   
 765 -    def __getfield_memo(self): 
 766          return self.__field_memo.getvalue() 
 767   
 768 -    def __setfield_memo(self, value): 
 769          if isinstance(value,USTRING): 
 770              self.__field_memo=value 
 771          else: 
 772              self.__field_memo=USTRING(value,**{'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'sizeinbytes': MEMOLENGTH}) 
 773   
 774 -    def __delfield_memo(self): del self.__field_memo 
 775   
 776      memo=property(__getfield_memo, __setfield_memo, __delfield_memo, None) 
 777   
 778 -    def __getfield_emails(self): 
 779          try: self.__field_emails 
 780          except: 
 781              self.__field_emails=LIST(**{'elementclass': _gen_p_lglx570_100, 'length': NUMEMAILS}) 
 782          return self.__field_emails.getvalue() 
 783   
 784 -    def __setfield_emails(self, value): 
 785          if isinstance(value,LIST): 
 786              self.__field_emails=value 
 787          else: 
 788              self.__field_emails=LIST(value,**{'elementclass': _gen_p_lglx570_100, 'length': NUMEMAILS}) 
 789   
 790 -    def __delfield_emails(self): del self.__field_emails 
 791   
 792      emails=property(__getfield_emails, __setfield_emails, __delfield_emails, None) 
 793   
 794 -    def __getfield_url(self): 
 795          return self.__field_url.getvalue() 
 796   
 797 -    def __setfield_url(self, value): 
 798          if isinstance(value,USTRING): 
 799              self.__field_url=value 
 800          else: 
 801              self.__field_url=USTRING(value,**{'sizeinbytes': 73, 'raiseonunterminatedread': False}) 
 802   
 803 -    def __delfield_url(self): del self.__field_url 
 804   
 805      url=property(__getfield_url, __setfield_url, __delfield_url, None) 
 806   
 807 -    def __getfield_speeddials(self): 
 808          try: self.__field_speeddials 
 809          except: 
 810              self.__field_speeddials=LIST(**{'elementclass': _gen_p_lglx570_103,  'length': NUMPHONENUMBERS }) 
 811          return self.__field_speeddials.getvalue() 
 812   
 813 -    def __setfield_speeddials(self, value): 
 814          if isinstance(value,LIST): 
 815              self.__field_speeddials=value 
 816          else: 
 817              self.__field_speeddials=LIST(value,**{'elementclass': _gen_p_lglx570_103,  'length': NUMPHONENUMBERS }) 
 818   
 819 -    def __delfield_speeddials(self): del self.__field_speeddials 
 820   
 821      speeddials=property(__getfield_speeddials, __setfield_speeddials, __delfield_speeddials, None) 
 822   
 823 -    def __getfield_numbertypes(self): 
 824          try: self.__field_numbertypes 
 825          except: 
 826              self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lglx570_105, 'length': NUMPHONENUMBERS}) 
 827          return self.__field_numbertypes.getvalue() 
 828   
 829 -    def __setfield_numbertypes(self, value): 
 830          if isinstance(value,LIST): 
 831              self.__field_numbertypes=value 
 832          else: 
 833              self.__field_numbertypes=LIST(value,**{'elementclass': _gen_p_lglx570_105, 'length': NUMPHONENUMBERS}) 
 834   
 835 -    def __delfield_numbertypes(self): del self.__field_numbertypes 
 836   
 837      numbertypes=property(__getfield_numbertypes, __setfield_numbertypes, __delfield_numbertypes, None) 
 838   
 839 -    def __getfield_numbers(self): 
 840          try: self.__field_numbers 
 841          except: 
 842              self.__field_numbers=LIST(**{'elementclass': _gen_p_lglx570_107, 'length': NUMPHONENUMBERS}) 
 843          return self.__field_numbers.getvalue() 
 844   
 845 -    def __setfield_numbers(self, value): 
 846          if isinstance(value,LIST): 
 847              self.__field_numbers=value 
 848          else: 
 849              self.__field_numbers=LIST(value,**{'elementclass': _gen_p_lglx570_107, 'length': NUMPHONENUMBERS}) 
 850   
 851 -    def __delfield_numbers(self): del self.__field_numbers 
 852   
 853      numbers=property(__getfield_numbers, __setfield_numbers, __delfield_numbers, None) 
 854   
 855 -    def __getfield_dunno3(self): 
 856          try: self.__field_dunno3 
 857          except: 
 858              self.__field_dunno3=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
 859          return self.__field_dunno3.getvalue() 
 860   
 861 -    def __setfield_dunno3(self, value): 
 862          if isinstance(value,UINT): 
 863              self.__field_dunno3=value 
 864          else: 
 865              self.__field_dunno3=UINT(value,**{'sizeinbytes': 2,  'default': 0 }) 
 866   
 867 -    def __delfield_dunno3(self): del self.__field_dunno3 
 868   
 869      dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None) 
 870   
 871 -    def __getfield_wallpaper(self): 
 872          try: self.__field_wallpaper 
 873          except: 
 874              self.__field_wallpaper=UINT(**{ 'default': 0 }) 
 875          return self.__field_wallpaper.getvalue() 
 876   
 877 -    def __setfield_wallpaper(self, value): 
 878          if isinstance(value,UINT): 
 879              self.__field_wallpaper=value 
 880          else: 
 881              self.__field_wallpaper=UINT(value,**{ 'default': 0 }) 
 882   
 883 -    def __delfield_wallpaper(self): del self.__field_wallpaper 
 884   
 885      wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None) 
 886   
 887 -    def iscontainer(self): 
 888          return True 
 889   
 890 -    def containerelements(self): 
 891          yield ('serial1', self.__field_serial1, None) 
 892          yield ('entrysize', self.__field_entrysize, None) 
 893          yield ('serial2', self.__field_serial2, None) 
 894          yield ('entrynumber', self.__field_entrynumber, None) 
 895          yield ('name', self.__field_name, None) 
 896          yield ('group', self.__field_group, None) 
 897          yield ('dunno1', self.__field_dunno1, None) 
 898          yield ('ringtone', self.__field_ringtone, None) 
 899          yield ('dunno2', self.__field_dunno2, None) 
 900          yield ('memo', self.__field_memo, None) 
 901          yield ('emails', self.__field_emails, None) 
 902          yield ('url', self.__field_url, None) 
 903          yield ('speeddials', self.__field_speeddials, None) 
 904          yield ('numbertypes', self.__field_numbertypes, None) 
 905          yield ('numbers', self.__field_numbers, None) 
 906          yield ('dunno3', self.__field_dunno3, None) 
 907          yield ('wallpaper', self.__field_wallpaper, None) 
 908   
 909   
 910   
 911   
 912 -class _gen_p_lglx570_100(BaseProtogenClass): 
 913      'Anonymous inner class' 
 914      __fields=['email'] 
 915   
 916 -    def __init__(self, *args, **kwargs): 
 917          dict={} 
 918          # What was supplied to this function 
 919          dict.update(kwargs) 
 920          # Parent constructor 
 921          super(_gen_p_lglx570_100,self).__init__(**dict) 
 922          if self.__class__ is _gen_p_lglx570_100: 
 923              self._update(args,dict) 
 924   
 925   
 926 -    def getfields(self): 
 927          return self.__fields 
 928   
 929   
 930 -    def _update(self, args, kwargs): 
 931          super(_gen_p_lglx570_100,self)._update(args,kwargs) 
 932          keys=kwargs.keys() 
 933          for key in keys: 
 934              if key in self.__fields: 
 935                  setattr(self, key, kwargs[key]) 
 936                  del kwargs[key] 
 937          # Were any unrecognized kwargs passed in? 
 938          if __debug__: 
 939              self._complainaboutunusedargs(_gen_p_lglx570_100,kwargs) 
 940          if len(args): 
 941              dict2={'sizeinbytes': 73, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False} 
 942              dict2.update(kwargs) 
 943              kwargs=dict2 
 944              self.__field_email=USTRING(*args,**dict2) 
 945          # Make all P fields that haven't already been constructed 
 946   
 947   
 948 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 949          'Writes this packet to the supplied buffer' 
 950          self._bufferstartoffset=buf.getcurrentoffset() 
 951          self.__field_email.writetobuffer(buf) 
 952          self._bufferendoffset=buf.getcurrentoffset() 
 953          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 954   
 955   
 956 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 957          'Reads this packet from the supplied buffer' 
 958          self._bufferstartoffset=buf.getcurrentoffset() 
 959          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 960          self.__field_email=USTRING(**{'sizeinbytes': 73, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
 961          self.__field_email.readfrombuffer(buf) 
 962          self._bufferendoffset=buf.getcurrentoffset() 
 963   
 964   
 965 -    def __getfield_email(self): 
 966          return self.__field_email.getvalue() 
 967   
 968 -    def __setfield_email(self, value): 
 969          if isinstance(value,USTRING): 
 970              self.__field_email=value 
 971          else: 
 972              self.__field_email=USTRING(value,**{'sizeinbytes': 73, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
 973   
 974 -    def __delfield_email(self): del self.__field_email 
 975   
 976      email=property(__getfield_email, __setfield_email, __delfield_email, None) 
 977   
 978 -    def iscontainer(self): 
 979          return True 
 980   
 981 -    def containerelements(self): 
 982          yield ('email', self.__field_email, None) 
 983   
 984   
 985   
 986   
 987 -class _gen_p_lglx570_103(BaseProtogenClass): 
 988      'Anonymous inner class' 
 989      __fields=['speeddial'] 
 990   
 991 -    def __init__(self, *args, **kwargs): 
 992          dict={} 
 993          # What was supplied to this function 
 994          dict.update(kwargs) 
 995          # Parent constructor 
 996          super(_gen_p_lglx570_103,self).__init__(**dict) 
 997          if self.__class__ is _gen_p_lglx570_103: 
 998              self._update(args,dict) 
 999   
1000   
1001 -    def getfields(self): 
1002          return self.__fields 
1003   
1004   
1005 -    def _update(self, args, kwargs): 
1006          super(_gen_p_lglx570_103,self)._update(args,kwargs) 
1007          keys=kwargs.keys() 
1008          for key in keys: 
1009              if key in self.__fields: 
1010                  setattr(self, key, kwargs[key]) 
1011                  del kwargs[key] 
1012          # Were any unrecognized kwargs passed in? 
1013          if __debug__: 
1014              self._complainaboutunusedargs(_gen_p_lglx570_103,kwargs) 
1015          if len(args): 
1016              dict2={'sizeinbytes': 1,  'default': 0xff } 
1017              dict2.update(kwargs) 
1018              kwargs=dict2 
1019              self.__field_speeddial=UINT(*args,**dict2) 
1020          # Make all P fields that haven't already been constructed 
1021   
1022   
1023 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1024          'Writes this packet to the supplied buffer' 
1025          self._bufferstartoffset=buf.getcurrentoffset() 
1026          try: self.__field_speeddial 
1027          except: 
1028              self.__field_speeddial=UINT(**{'sizeinbytes': 1,  'default': 0xff }) 
1029          self.__field_speeddial.writetobuffer(buf) 
1030          self._bufferendoffset=buf.getcurrentoffset() 
1031          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1032   
1033   
1034 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1035          'Reads this packet from the supplied buffer' 
1036          self._bufferstartoffset=buf.getcurrentoffset() 
1037          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1038          self.__field_speeddial=UINT(**{'sizeinbytes': 1,  'default': 0xff }) 
1039          self.__field_speeddial.readfrombuffer(buf) 
1040          self._bufferendoffset=buf.getcurrentoffset() 
1041   
1042   
1043 -    def __getfield_speeddial(self): 
1044          try: self.__field_speeddial 
1045          except: 
1046              self.__field_speeddial=UINT(**{'sizeinbytes': 1,  'default': 0xff }) 
1047          return self.__field_speeddial.getvalue() 
1048   
1049 -    def __setfield_speeddial(self, value): 
1050          if isinstance(value,UINT): 
1051              self.__field_speeddial=value 
1052          else: 
1053              self.__field_speeddial=UINT(value,**{'sizeinbytes': 1,  'default': 0xff }) 
1054   
1055 -    def __delfield_speeddial(self): del self.__field_speeddial 
1056   
1057      speeddial=property(__getfield_speeddial, __setfield_speeddial, __delfield_speeddial, None) 
1058   
1059 -    def iscontainer(self): 
1060          return True 
1061   
1062 -    def containerelements(self): 
1063          yield ('speeddial', self.__field_speeddial, None) 
1064   
1065   
1066   
1067   
1068 -class _gen_p_lglx570_105(BaseProtogenClass): 
1069      'Anonymous inner class' 
1070      __fields=['numbertype'] 
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(_gen_p_lglx570_105,self).__init__(**dict) 
1078          if self.__class__ is _gen_p_lglx570_105: 
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(_gen_p_lglx570_105,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(_gen_p_lglx570_105,kwargs) 
1096          if len(args): 
1097              dict2={'sizeinbytes': 1} 
1098              dict2.update(kwargs) 
1099              kwargs=dict2 
1100              self.__field_numbertype=UINT(*args,**dict2) 
1101          # Make all P fields that haven't already been constructed 
1102   
1103   
1104 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1105          'Writes this packet to the supplied buffer' 
1106          self._bufferstartoffset=buf.getcurrentoffset() 
1107          self.__field_numbertype.writetobuffer(buf) 
1108          self._bufferendoffset=buf.getcurrentoffset() 
1109          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1110   
1111   
1112 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1113          'Reads this packet from the supplied buffer' 
1114          self._bufferstartoffset=buf.getcurrentoffset() 
1115          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1116          self.__field_numbertype=UINT(**{'sizeinbytes': 1}) 
1117          self.__field_numbertype.readfrombuffer(buf) 
1118          self._bufferendoffset=buf.getcurrentoffset() 
1119   
1120   
1121 -    def __getfield_numbertype(self): 
1122          return self.__field_numbertype.getvalue() 
1123   
1124 -    def __setfield_numbertype(self, value): 
1125          if isinstance(value,UINT): 
1126              self.__field_numbertype=value 
1127          else: 
1128              self.__field_numbertype=UINT(value,**{'sizeinbytes': 1}) 
1129   
1130 -    def __delfield_numbertype(self): del self.__field_numbertype 
1131   
1132      numbertype=property(__getfield_numbertype, __setfield_numbertype, __delfield_numbertype, None) 
1133   
1134 -    def iscontainer(self): 
1135          return True 
1136   
1137 -    def containerelements(self): 
1138          yield ('numbertype', self.__field_numbertype, None) 
1139   
1140   
1141   
1142   
1143 -class _gen_p_lglx570_107(BaseProtogenClass): 
1144      'Anonymous inner class' 
1145      __fields=['number'] 
1146   
1147 -    def __init__(self, *args, **kwargs): 
1148          dict={} 
1149          # What was supplied to this function 
1150          dict.update(kwargs) 
1151          # Parent constructor 
1152          super(_gen_p_lglx570_107,self).__init__(**dict) 
1153          if self.__class__ is _gen_p_lglx570_107: 
1154              self._update(args,dict) 
1155   
1156   
1157 -    def getfields(self): 
1158          return self.__fields 
1159   
1160   
1161 -    def _update(self, args, kwargs): 
1162          super(_gen_p_lglx570_107,self)._update(args,kwargs) 
1163          keys=kwargs.keys() 
1164          for key in keys: 
1165              if key in self.__fields: 
1166                  setattr(self, key, kwargs[key]) 
1167                  del kwargs[key] 
1168          # Were any unrecognized kwargs passed in? 
1169          if __debug__: 
1170              self._complainaboutunusedargs(_gen_p_lglx570_107,kwargs) 
1171          if len(args): 
1172              dict2={'sizeinbytes': 49, 'raiseonunterminatedread': False} 
1173              dict2.update(kwargs) 
1174              kwargs=dict2 
1175              self.__field_number=USTRING(*args,**dict2) 
1176          # Make all P fields that haven't already been constructed 
1177   
1178   
1179 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1180          'Writes this packet to the supplied buffer' 
1181          self._bufferstartoffset=buf.getcurrentoffset() 
1182          self.__field_number.writetobuffer(buf) 
1183          self._bufferendoffset=buf.getcurrentoffset() 
1184          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1185   
1186   
1187 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1188          'Reads this packet from the supplied buffer' 
1189          self._bufferstartoffset=buf.getcurrentoffset() 
1190          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1191          self.__field_number=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 
1192          self.__field_number.readfrombuffer(buf) 
1193          self._bufferendoffset=buf.getcurrentoffset() 
1194   
1195   
1196 -    def __getfield_number(self): 
1197          return self.__field_number.getvalue() 
1198   
1199 -    def __setfield_number(self, value): 
1200          if isinstance(value,USTRING): 
1201              self.__field_number=value 
1202          else: 
1203              self.__field_number=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 
1204   
1205 -    def __delfield_number(self): del self.__field_number 
1206   
1207      number=property(__getfield_number, __setfield_number, __delfield_number, None) 
1208   
1209 -    def iscontainer(self): 
1210          return True 
1211   
1212 -    def containerelements(self): 
1213          yield ('number', self.__field_number, None) 
1214   
1215   
1216   
1217   
1218 -class pbgroup(BaseProtogenClass): 
1219      "A single group" 
1220      __fields=['header', 'blocksize', 'dunno2', 'groupid', 'dunno3', 'name'] 
1221   
1222 -    def __init__(self, *args, **kwargs): 
1223          dict={} 
1224          # What was supplied to this function 
1225          dict.update(kwargs) 
1226          # Parent constructor 
1227          super(pbgroup,self).__init__(**dict) 
1228          if self.__class__ is pbgroup: 
1229              self._update(args,dict) 
1230   
1231   
1232 -    def getfields(self): 
1233          return self.__fields 
1234   
1235   
1236 -    def _update(self, args, kwargs): 
1237          super(pbgroup,self)._update(args,kwargs) 
1238          keys=kwargs.keys() 
1239          for key in keys: 
1240              if key in self.__fields: 
1241                  setattr(self, key, kwargs[key]) 
1242                  del kwargs[key] 
1243          # Were any unrecognized kwargs passed in? 
1244          if __debug__: 
1245              self._complainaboutunusedargs(pbgroup,kwargs) 
1246          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1247          # Make all P fields that haven't already been constructed 
1248   
1249   
1250 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1251          'Writes this packet to the supplied buffer' 
1252          self._bufferstartoffset=buf.getcurrentoffset() 
1253          self.__field_header.writetobuffer(buf) 
1254          if self.valid: 
1255              self.__field_blocksize.writetobuffer(buf) 
1256              self.__field_dunno2.writetobuffer(buf) 
1257              self.__field_groupid.writetobuffer(buf) 
1258              self.__field_dunno3.writetobuffer(buf) 
1259              self.__field_name.writetobuffer(buf) 
1260          self._bufferendoffset=buf.getcurrentoffset() 
1261          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1262   
1263   
1264 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1265          'Reads this packet from the supplied buffer' 
1266          self._bufferstartoffset=buf.getcurrentoffset() 
1267          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1268          self.__field_header=UINT(**{'sizeinbytes': 2}) 
1269          self.__field_header.readfrombuffer(buf) 
1270          if self.valid: 
1271              self.__field_blocksize=UINT(**{'sizeinbytes': 2}) 
1272              self.__field_blocksize.readfrombuffer(buf) 
1273              self.__field_dunno2=DATA(**{'sizeinbytes': 9}) 
1274              self.__field_dunno2.readfrombuffer(buf) 
1275              self.__field_groupid=UINT(**{'sizeinbytes': 2}) 
1276              self.__field_groupid.readfrombuffer(buf) 
1277              self.__field_dunno3=DATA(**{'sizeinbytes': 16}) 
1278              self.__field_dunno3.readfrombuffer(buf) 
1279              self.__field_name=USTRING(**{ 'encoding': PHONE_ENCODING,                    'sizeinbytes': self.namesize }) 
1280              self.__field_name.readfrombuffer(buf) 
1281          self._bufferendoffset=buf.getcurrentoffset() 
1282   
1283   
1284 -    def __getfield_header(self): 
1285          return self.__field_header.getvalue() 
1286   
1287 -    def __setfield_header(self, value): 
1288          if isinstance(value,UINT): 
1289              self.__field_header=value 
1290          else: 
1291              self.__field_header=UINT(value,**{'sizeinbytes': 2}) 
1292   
1293 -    def __delfield_header(self): del self.__field_header 
1294   
1295      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
1296   
1297 -    def __getfield_blocksize(self): 
1298          return self.__field_blocksize.getvalue() 
1299   
1300 -    def __setfield_blocksize(self, value): 
1301          if isinstance(value,UINT): 
1302              self.__field_blocksize=value 
1303          else: 
1304              self.__field_blocksize=UINT(value,**{'sizeinbytes': 2}) 
1305   
1306 -    def __delfield_blocksize(self): del self.__field_blocksize 
1307   
1308      blocksize=property(__getfield_blocksize, __setfield_blocksize, __delfield_blocksize, None) 
1309   
1310 -    def __getfield_dunno2(self): 
1311          return self.__field_dunno2.getvalue() 
1312   
1313 -    def __setfield_dunno2(self, value): 
1314          if isinstance(value,DATA): 
1315              self.__field_dunno2=value 
1316          else: 
1317              self.__field_dunno2=DATA(value,**{'sizeinbytes': 9}) 
1318   
1319 -    def __delfield_dunno2(self): del self.__field_dunno2 
1320   
1321      dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None) 
1322   
1323 -    def __getfield_groupid(self): 
1324          return self.__field_groupid.getvalue() 
1325   
1326 -    def __setfield_groupid(self, value): 
1327          if isinstance(value,UINT): 
1328              self.__field_groupid=value 
1329          else: 
1330              self.__field_groupid=UINT(value,**{'sizeinbytes': 2}) 
1331   
1332 -    def __delfield_groupid(self): del self.__field_groupid 
1333   
1334      groupid=property(__getfield_groupid, __setfield_groupid, __delfield_groupid, None) 
1335   
1336 -    def __getfield_dunno3(self): 
1337          return self.__field_dunno3.getvalue() 
1338   
1339 -    def __setfield_dunno3(self, value): 
1340          if isinstance(value,DATA): 
1341              self.__field_dunno3=value 
1342          else: 
1343              self.__field_dunno3=DATA(value,**{'sizeinbytes': 16}) 
1344   
1345 -    def __delfield_dunno3(self): del self.__field_dunno3 
1346   
1347      dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None) 
1348   
1349 -    def __getfield_name(self): 
1350          return self.__field_name.getvalue() 
1351   
1352 -    def __setfield_name(self, value): 
1353          if isinstance(value,USTRING): 
1354              self.__field_name=value 
1355          else: 
1356              self.__field_name=USTRING(value,**{ 'encoding': PHONE_ENCODING,                    'sizeinbytes': self.namesize }) 
1357   
1358 -    def __delfield_name(self): del self.__field_name 
1359   
1360      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
1361   
1362 -    def iscontainer(self): 
1363          return True 
1364   
1365 -    def containerelements(self): 
1366          yield ('header', self.__field_header, None) 
1367          if self.valid: 
1368              yield ('blocksize', self.__field_blocksize, None) 
1369              yield ('dunno2', self.__field_dunno2, None) 
1370              yield ('groupid', self.__field_groupid, None) 
1371              yield ('dunno3', self.__field_dunno3, None) 
1372              yield ('name', self.__field_name, None) 
1373   
1374 -    def _getnamesize(self): 
1375          # Return the length of the name, the size of data block must be on a 
1376          # 4-byte word boundary 
1377          _rem4=self.blocksize%4 
1378          if _rem4: 
1379              return self.blocksize+4-_rem4-27 
1380          else: 
1381              return self.blocksize-27 
1382      namesize=property(fget=_getnamesize) 
1383 -    def _getvalid(self): 
1384          return self.header!=0xffff 
1385      valid=property(fget=_getvalid) 
1386   
1387   
1388   
1389   
1390 -class pbgroups(BaseProtogenClass): 
1391      "Phonebook groups" 
1392      __fields=['groups'] 
1393   
1394 -    def __init__(self, *args, **kwargs): 
1395          dict={} 
1396          # What was supplied to this function 
1397          dict.update(kwargs) 
1398          # Parent constructor 
1399          super(pbgroups,self).__init__(**dict) 
1400          if self.__class__ is pbgroups: 
1401              self._update(args,dict) 
1402   
1403   
1404 -    def getfields(self): 
1405          return self.__fields 
1406   
1407   
1408 -    def _update(self, args, kwargs): 
1409          super(pbgroups,self)._update(args,kwargs) 
1410          keys=kwargs.keys() 
1411          for key in keys: 
1412              if key in self.__fields: 
1413                  setattr(self, key, kwargs[key]) 
1414                  del kwargs[key] 
1415          # Were any unrecognized kwargs passed in? 
1416          if __debug__: 
1417              self._complainaboutunusedargs(pbgroups,kwargs) 
1418          if len(args): 
1419              dict2={'elementclass': pbgroup} 
1420              dict2.update(kwargs) 
1421              kwargs=dict2 
1422              self.__field_groups=LIST(*args,**dict2) 
1423          # Make all P fields that haven't already been constructed 
1424   
1425   
1426 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1427          'Writes this packet to the supplied buffer' 
1428          self._bufferstartoffset=buf.getcurrentoffset() 
1429          try: self.__field_groups 
1430          except: 
1431              self.__field_groups=LIST(**{'elementclass': pbgroup}) 
1432          self.__field_groups.writetobuffer(buf) 
1433          self._bufferendoffset=buf.getcurrentoffset() 
1434          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1435   
1436   
1437 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1438          'Reads this packet from the supplied buffer' 
1439          self._bufferstartoffset=buf.getcurrentoffset() 
1440          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1441          self.__field_groups=LIST(**{'elementclass': pbgroup}) 
1442          self.__field_groups.readfrombuffer(buf) 
1443          self._bufferendoffset=buf.getcurrentoffset() 
1444   
1445   
1446 -    def __getfield_groups(self): 
1447          try: self.__field_groups 
1448          except: 
1449              self.__field_groups=LIST(**{'elementclass': pbgroup}) 
1450          return self.__field_groups.getvalue() 
1451   
1452 -    def __setfield_groups(self, value): 
1453          if isinstance(value,LIST): 
1454              self.__field_groups=value 
1455          else: 
1456              self.__field_groups=LIST(value,**{'elementclass': pbgroup}) 
1457   
1458 -    def __delfield_groups(self): del self.__field_groups 
1459   
1460      groups=property(__getfield_groups, __setfield_groups, __delfield_groups, None) 
1461   
1462 -    def iscontainer(self): 
1463          return True 
1464   
1465 -    def containerelements(self): 
1466          yield ('groups', self.__field_groups, None) 
1467   
1468   
1469   
1470   
1471 -class textmemo(BaseProtogenClass): 
1472      __fields=['text'] 
1473   
1474 -    def __init__(self, *args, **kwargs): 
1475          dict={} 
1476          # What was supplied to this function 
1477          dict.update(kwargs) 
1478          # Parent constructor 
1479          super(textmemo,self).__init__(**dict) 
1480          if self.__class__ is textmemo: 
1481              self._update(args,dict) 
1482   
1483   
1484 -    def getfields(self): 
1485          return self.__fields 
1486   
1487   
1488 -    def _update(self, args, kwargs): 
1489          super(textmemo,self)._update(args,kwargs) 
1490          keys=kwargs.keys() 
1491          for key in keys: 
1492              if key in self.__fields: 
1493                  setattr(self, key, kwargs[key]) 
1494                  del kwargs[key] 
1495          # Were any unrecognized kwargs passed in? 
1496          if __debug__: 
1497              self._complainaboutunusedargs(textmemo,kwargs) 
1498          if len(args): 
1499              dict2={'sizeinbytes': 1001,  'encoding': PHONE_ENCODING,                   'raiseonunterminatedread': False,                   'raiseontruncate': False } 
1500              dict2.update(kwargs) 
1501              kwargs=dict2 
1502              self.__field_text=USTRING(*args,**dict2) 
1503          # Make all P fields that haven't already been constructed 
1504   
1505   
1506 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1507          'Writes this packet to the supplied buffer' 
1508          self._bufferstartoffset=buf.getcurrentoffset() 
1509          self.__field_text.writetobuffer(buf) 
1510          self._bufferendoffset=buf.getcurrentoffset() 
1511          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1512   
1513   
1514 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1515          'Reads this packet from the supplied buffer' 
1516          self._bufferstartoffset=buf.getcurrentoffset() 
1517          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1518          self.__field_text=USTRING(**{'sizeinbytes': 1001,  'encoding': PHONE_ENCODING,                   'raiseonunterminatedread': False,                   'raiseontruncate': False }) 
1519          self.__field_text.readfrombuffer(buf) 
1520          self._bufferendoffset=buf.getcurrentoffset() 
1521   
1522   
1523 -    def __getfield_text(self): 
1524          return self.__field_text.getvalue() 
1525   
1526 -    def __setfield_text(self, value): 
1527          if isinstance(value,USTRING): 
1528              self.__field_text=value 
1529          else: 
1530              self.__field_text=USTRING(value,**{'sizeinbytes': 1001,  'encoding': PHONE_ENCODING,                   'raiseonunterminatedread': False,                   'raiseontruncate': False }) 
1531   
1532 -    def __delfield_text(self): del self.__field_text 
1533   
1534      text=property(__getfield_text, __setfield_text, __delfield_text, None) 
1535   
1536 -    def iscontainer(self): 
1537          return True 
1538   
1539 -    def containerelements(self): 
1540          yield ('text', self.__field_text, None) 
1541   
1542   
1543   
1544   
1545 -class textmemofile(BaseProtogenClass): 
1546      __fields=['itemcount', 'items'] 
1547   
1548 -    def __init__(self, *args, **kwargs): 
1549          dict={} 
1550          # What was supplied to this function 
1551          dict.update(kwargs) 
1552          # Parent constructor 
1553          super(textmemofile,self).__init__(**dict) 
1554          if self.__class__ is textmemofile: 
1555              self._update(args,dict) 
1556   
1557   
1558 -    def getfields(self): 
1559          return self.__fields 
1560   
1561   
1562 -    def _update(self, args, kwargs): 
1563          super(textmemofile,self)._update(args,kwargs) 
1564          keys=kwargs.keys() 
1565          for key in keys: 
1566              if key in self.__fields: 
1567                  setattr(self, key, kwargs[key]) 
1568                  del kwargs[key] 
1569          # Were any unrecognized kwargs passed in? 
1570          if __debug__: 
1571              self._complainaboutunusedargs(textmemofile,kwargs) 
1572          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1573          # Make all P fields that haven't already been constructed 
1574   
1575   
1576 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1577          'Writes this packet to the supplied buffer' 
1578          self._bufferstartoffset=buf.getcurrentoffset() 
1579          self.__field_itemcount.writetobuffer(buf) 
1580          try: self.__field_items 
1581          except: 
1582              self.__field_items=LIST(**{ 'elementclass': textmemo }) 
1583          self.__field_items.writetobuffer(buf) 
1584          self._bufferendoffset=buf.getcurrentoffset() 
1585          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1586   
1587   
1588 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1589          'Reads this packet from the supplied buffer' 
1590          self._bufferstartoffset=buf.getcurrentoffset() 
1591          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1592          self.__field_itemcount=UINT(**{'sizeinbytes': 4}) 
1593          self.__field_itemcount.readfrombuffer(buf) 
1594          self.__field_items=LIST(**{ 'elementclass': textmemo }) 
1595          self.__field_items.readfrombuffer(buf) 
1596          self._bufferendoffset=buf.getcurrentoffset() 
1597   
1598   
1599 -    def __getfield_itemcount(self): 
1600          return self.__field_itemcount.getvalue() 
1601   
1602 -    def __setfield_itemcount(self, value): 
1603          if isinstance(value,UINT): 
1604              self.__field_itemcount=value 
1605          else: 
1606              self.__field_itemcount=UINT(value,**{'sizeinbytes': 4}) 
1607   
1608 -    def __delfield_itemcount(self): del self.__field_itemcount 
1609   
1610      itemcount=property(__getfield_itemcount, __setfield_itemcount, __delfield_itemcount, None) 
1611   
1612 -    def __getfield_items(self): 
1613          try: self.__field_items 
1614          except: 
1615              self.__field_items=LIST(**{ 'elementclass': textmemo }) 
1616          return self.__field_items.getvalue() 
1617   
1618 -    def __setfield_items(self, value): 
1619          if isinstance(value,LIST): 
1620              self.__field_items=value 
1621          else: 
1622              self.__field_items=LIST(value,**{ 'elementclass': textmemo }) 
1623   
1624 -    def __delfield_items(self): del self.__field_items 
1625   
1626      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
1627   
1628 -    def iscontainer(self): 
1629          return True 
1630   
1631 -    def containerelements(self): 
1632          yield ('itemcount', self.__field_itemcount, None) 
1633          yield ('items', self.__field_items, None) 
1634   
1635   
1636   
1637   
1638 -class recipient_record(BaseProtogenClass): 
1639      __fields=['unknown1', 'name', 'number', 'status', 'unknown3', 'time', 'unknown2'] 
1640   
1641 -    def __init__(self, *args, **kwargs): 
1642          dict={} 
1643          # What was supplied to this function 
1644          dict.update(kwargs) 
1645          # Parent constructor 
1646          super(recipient_record,self).__init__(**dict) 
1647          if self.__class__ is recipient_record: 
1648              self._update(args,dict) 
1649   
1650   
1651 -    def getfields(self): 
1652          return self.__fields 
1653   
1654   
1655 -    def _update(self, args, kwargs): 
1656          super(recipient_record,self)._update(args,kwargs) 
1657          keys=kwargs.keys() 
1658          for key in keys: 
1659              if key in self.__fields: 
1660                  setattr(self, key, kwargs[key]) 
1661                  del kwargs[key] 
1662          # Were any unrecognized kwargs passed in? 
1663          if __debug__: 
1664              self._complainaboutunusedargs(recipient_record,kwargs) 
1665          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1666          # Make all P fields that haven't already been constructed 
1667   
1668   
1669 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1670          'Writes this packet to the supplied buffer' 
1671          self._bufferstartoffset=buf.getcurrentoffset() 
1672          self.__field_unknown1.writetobuffer(buf) 
1673          self.__field_name.writetobuffer(buf) 
1674          self.__field_number.writetobuffer(buf) 
1675          self.__field_status.writetobuffer(buf) 
1676          self.__field_unknown3.writetobuffer(buf) 
1677          self.__field_time.writetobuffer(buf) 
1678          self.__field_unknown2.writetobuffer(buf) 
1679          self._bufferendoffset=buf.getcurrentoffset() 
1680          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1681   
1682   
1683 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1684          'Reads this packet from the supplied buffer' 
1685          self._bufferstartoffset=buf.getcurrentoffset() 
1686          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1687          self.__field_unknown1=UINT(**{'sizeinbytes': 8}) 
1688          self.__field_unknown1.readfrombuffer(buf) 
1689          self.__field_name=USTRING(**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
1690          self.__field_name.readfrombuffer(buf) 
1691          self.__field_number=USTRING(**{'sizeinbytes': 73}) 
1692          self.__field_number.readfrombuffer(buf) 
1693          self.__field_status=UINT(**{'sizeinbytes': 1}) 
1694          self.__field_status.readfrombuffer(buf) 
1695          self.__field_unknown3=UINT(**{'sizeinbytes': 1}) 
1696          self.__field_unknown3.readfrombuffer(buf) 
1697          self.__field_time=LGCALDATE(**{'sizeinbytes': 4}) 
1698          self.__field_time.readfrombuffer(buf) 
1699          self.__field_unknown2=DATA(**{'sizeinbytes': 12}) 
1700          self.__field_unknown2.readfrombuffer(buf) 
1701          self._bufferendoffset=buf.getcurrentoffset() 
1702   
1703   
1704 -    def __getfield_unknown1(self): 
1705          return self.__field_unknown1.getvalue() 
1706   
1707 -    def __setfield_unknown1(self, value): 
1708          if isinstance(value,UINT): 
1709              self.__field_unknown1=value 
1710          else: 
1711              self.__field_unknown1=UINT(value,**{'sizeinbytes': 8}) 
1712   
1713 -    def __delfield_unknown1(self): del self.__field_unknown1 
1714   
1715      unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 
1716   
1717 -    def __getfield_name(self): 
1718          return self.__field_name.getvalue() 
1719   
1720 -    def __setfield_name(self, value): 
1721          if isinstance(value,USTRING): 
1722              self.__field_name=value 
1723          else: 
1724              self.__field_name=USTRING(value,**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
1725   
1726 -    def __delfield_name(self): del self.__field_name 
1727   
1728      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
1729   
1730 -    def __getfield_number(self): 
1731          return self.__field_number.getvalue() 
1732   
1733 -    def __setfield_number(self, value): 
1734          if isinstance(value,USTRING): 
1735              self.__field_number=value 
1736          else: 
1737              self.__field_number=USTRING(value,**{'sizeinbytes': 73}) 
1738   
1739 -    def __delfield_number(self): del self.__field_number 
1740   
1741      number=property(__getfield_number, __setfield_number, __delfield_number, None) 
1742   
1743 -    def __getfield_status(self): 
1744          return self.__field_status.getvalue() 
1745   
1746 -    def __setfield_status(self, value): 
1747          if isinstance(value,UINT): 
1748              self.__field_status=value 
1749          else: 
1750              self.__field_status=UINT(value,**{'sizeinbytes': 1}) 
1751   
1752 -    def __delfield_status(self): del self.__field_status 
1753   
1754      status=property(__getfield_status, __setfield_status, __delfield_status, None) 
1755   
1756 -    def __getfield_unknown3(self): 
1757          return self.__field_unknown3.getvalue() 
1758   
1759 -    def __setfield_unknown3(self, value): 
1760          if isinstance(value,UINT): 
1761              self.__field_unknown3=value 
1762          else: 
1763              self.__field_unknown3=UINT(value,**{'sizeinbytes': 1}) 
1764   
1765 -    def __delfield_unknown3(self): del self.__field_unknown3 
1766   
1767      unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None) 
1768   
1769 -    def __getfield_time(self): 
1770          return self.__field_time.getvalue() 
1771   
1772 -    def __setfield_time(self, value): 
1773          if isinstance(value,LGCALDATE): 
1774              self.__field_time=value 
1775          else: 
1776              self.__field_time=LGCALDATE(value,**{'sizeinbytes': 4}) 
1777   
1778 -    def __delfield_time(self): del self.__field_time 
1779   
1780      time=property(__getfield_time, __setfield_time, __delfield_time, None) 
1781   
1782 -    def __getfield_unknown2(self): 
1783          return self.__field_unknown2.getvalue() 
1784   
1785 -    def __setfield_unknown2(self, value): 
1786          if isinstance(value,DATA): 
1787              self.__field_unknown2=value 
1788          else: 
1789              self.__field_unknown2=DATA(value,**{'sizeinbytes': 12}) 
1790   
1791 -    def __delfield_unknown2(self): del self.__field_unknown2 
1792   
1793      unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None) 
1794   
1795 -    def iscontainer(self): 
1796          return True 
1797   
1798 -    def containerelements(self): 
1799          yield ('unknown1', self.__field_unknown1, None) 
1800          yield ('name', self.__field_name, None) 
1801          yield ('number', self.__field_number, None) 
1802          yield ('status', self.__field_status, None) 
1803          yield ('unknown3', self.__field_unknown3, None) 
1804          yield ('time', self.__field_time, None) 
1805          yield ('unknown2', self.__field_unknown2, None) 
1806   
1807   
1808   
1809   
1810 -class sms_out(BaseProtogenClass): 
1811      __fields=['index', 'locked', 'unknown1', 'timesent', 'dunno1', 'saved', 'dunno2', 'priority', 'dunno2', 'callback', 'msg', 'recipients'] 
1812   
1813 -    def __init__(self, *args, **kwargs): 
1814          dict={} 
1815          # What was supplied to this function 
1816          dict.update(kwargs) 
1817          # Parent constructor 
1818          super(sms_out,self).__init__(**dict) 
1819          if self.__class__ is sms_out: 
1820              self._update(args,dict) 
1821   
1822   
1823 -    def getfields(self): 
1824          return self.__fields 
1825   
1826   
1827 -    def _update(self, args, kwargs): 
1828          super(sms_out,self)._update(args,kwargs) 
1829          keys=kwargs.keys() 
1830          for key in keys: 
1831              if key in self.__fields: 
1832                  setattr(self, key, kwargs[key]) 
1833                  del kwargs[key] 
1834          # Were any unrecognized kwargs passed in? 
1835          if __debug__: 
1836              self._complainaboutunusedargs(sms_out,kwargs) 
1837          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1838          # Make all P fields that haven't already been constructed 
1839   
1840   
1841 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1842          'Writes this packet to the supplied buffer' 
1843          self._bufferstartoffset=buf.getcurrentoffset() 
1844          self.__field_index.writetobuffer(buf) 
1845          self.__field_locked.writetobuffer(buf) 
1846          self.__field_unknown1.writetobuffer(buf) 
1847          self.__field_timesent.writetobuffer(buf) 
1848          self.__field_dunno1.writetobuffer(buf) 
1849          self.__field_saved.writetobuffer(buf) 
1850          self.__field_dunno2.writetobuffer(buf) 
1851          self.__field_priority.writetobuffer(buf) 
1852          self.__field_dunno2.writetobuffer(buf) 
1853          self.__field_callback.writetobuffer(buf) 
1854          self.__field_msg.writetobuffer(buf) 
1855          try: self.__field_recipients 
1856          except: 
1857              self.__field_recipients=LIST(**{'elementclass': recipient_record, 'length': 10}) 
1858          self.__field_recipients.writetobuffer(buf) 
1859          self._bufferendoffset=buf.getcurrentoffset() 
1860          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1861   
1862   
1863 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1864          'Reads this packet from the supplied buffer' 
1865          self._bufferstartoffset=buf.getcurrentoffset() 
1866          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1867          self.__field_index=UINT(**{'sizeinbytes': 4}) 
1868          self.__field_index.readfrombuffer(buf) 
1869          self.__field_locked=UINT(**{'sizeinbytes': 1}) 
1870          self.__field_locked.readfrombuffer(buf) 
1871          self.__field_unknown1=UINT(**{'sizeinbytes': 3}) 
1872          self.__field_unknown1.readfrombuffer(buf) 
1873          self.__field_timesent=LGCALDATE(**{'sizeinbytes': 4}) 
1874          self.__field_timesent.readfrombuffer(buf) 
1875          self.__field_dunno1=DATA(**{'sizeinbytes': 2}) 
1876          self.__field_dunno1.readfrombuffer(buf) 
1877          self.__field_saved=UINT(**{'sizeinbytes': 1}) 
1878          self.__field_saved.readfrombuffer(buf) 
1879          self.__field_dunno2=DATA(**{'sizeinbytes': 5}) 
1880          self.__field_dunno2.readfrombuffer(buf) 
1881          self.__field_priority=UINT(**{'sizeinbytes': 1}) 
1882          self.__field_priority.readfrombuffer(buf) 
1883          self.__field_dunno2=DATA(**{'sizeinbytes': 15}) 
1884          self.__field_dunno2.readfrombuffer(buf) 
1885          self.__field_callback=USTRING(**{'sizeinbytes': 20}) 
1886          self.__field_callback.readfrombuffer(buf) 
1887          self.__field_msg=USTRING(**{'sizeinbytes': 160, 'encoding': PHONE_ENCODING}) 
1888          self.__field_msg.readfrombuffer(buf) 
1889          self.__field_recipients=LIST(**{'elementclass': recipient_record, 'length': 10}) 
1890          self.__field_recipients.readfrombuffer(buf) 
1891          self._bufferendoffset=buf.getcurrentoffset() 
1892   
1893   
1894 -    def __getfield_index(self): 
1895          return self.__field_index.getvalue() 
1896   
1897 -    def __setfield_index(self, value): 
1898          if isinstance(value,UINT): 
1899              self.__field_index=value 
1900          else: 
1901              self.__field_index=UINT(value,**{'sizeinbytes': 4}) 
1902   
1903 -    def __delfield_index(self): del self.__field_index 
1904   
1905      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
1906   
1907 -    def __getfield_locked(self): 
1908          return self.__field_locked.getvalue() 
1909   
1910 -    def __setfield_locked(self, value): 
1911          if isinstance(value,UINT): 
1912              self.__field_locked=value 
1913          else: 
1914              self.__field_locked=UINT(value,**{'sizeinbytes': 1}) 
1915   
1916 -    def __delfield_locked(self): del self.__field_locked 
1917   
1918      locked=property(__getfield_locked, __setfield_locked, __delfield_locked, None) 
1919   
1920 -    def __getfield_unknown1(self): 
1921          return self.__field_unknown1.getvalue() 
1922   
1923 -    def __setfield_unknown1(self, value): 
1924          if isinstance(value,UINT): 
1925              self.__field_unknown1=value 
1926          else: 
1927              self.__field_unknown1=UINT(value,**{'sizeinbytes': 3}) 
1928   
1929 -    def __delfield_unknown1(self): del self.__field_unknown1 
1930   
1931      unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 
1932   
1933 -    def __getfield_timesent(self): 
1934          return self.__field_timesent.getvalue() 
1935   
1936 -    def __setfield_timesent(self, value): 
1937          if isinstance(value,LGCALDATE): 
1938              self.__field_timesent=value 
1939          else: 
1940              self.__field_timesent=LGCALDATE(value,**{'sizeinbytes': 4}) 
1941   
1942 -    def __delfield_timesent(self): del self.__field_timesent 
1943   
1944      timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None) 
1945   
1946 -    def __getfield_dunno1(self): 
1947          return self.__field_dunno1.getvalue() 
1948   
1949 -    def __setfield_dunno1(self, value): 
1950          if isinstance(value,DATA): 
1951              self.__field_dunno1=value 
1952          else: 
1953              self.__field_dunno1=DATA(value,**{'sizeinbytes': 2}) 
1954   
1955 -    def __delfield_dunno1(self): del self.__field_dunno1 
1956   
1957      dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None) 
1958   
1959 -    def __getfield_saved(self): 
1960          return self.__field_saved.getvalue() 
1961   
1962 -    def __setfield_saved(self, value): 
1963          if isinstance(value,UINT): 
1964              self.__field_saved=value 
1965          else: 
1966              self.__field_saved=UINT(value,**{'sizeinbytes': 1}) 
1967   
1968 -    def __delfield_saved(self): del self.__field_saved 
1969   
1970      saved=property(__getfield_saved, __setfield_saved, __delfield_saved, None) 
1971   
1972 -    def __getfield_dunno2(self): 
1973          return self.__field_dunno2.getvalue() 
1974   
1975 -    def __setfield_dunno2(self, value): 
1976          if isinstance(value,DATA): 
1977              self.__field_dunno2=value 
1978          else: 
1979              self.__field_dunno2=DATA(value,**{'sizeinbytes': 5}) 
1980   
1981 -    def __delfield_dunno2(self): del self.__field_dunno2 
1982   
1983      dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None) 
1984   
1985 -    def __getfield_priority(self): 
1986          return self.__field_priority.getvalue() 
1987   
1988 -    def __setfield_priority(self, value): 
1989          if isinstance(value,UINT): 
1990              self.__field_priority=value 
1991          else: 
1992              self.__field_priority=UINT(value,**{'sizeinbytes': 1}) 
1993   
1994 -    def __delfield_priority(self): del self.__field_priority 
1995   
1996      priority=property(__getfield_priority, __setfield_priority, __delfield_priority, "0=normal, 1=urgent") 
1997   
1998 -    def __getfield_dunno2(self): 
1999          return self.__field_dunno2.getvalue() 
2000   
2001 -    def __setfield_dunno2(self, value): 
2002          if isinstance(value,DATA): 
2003              self.__field_dunno2=value 
2004          else: 
2005              self.__field_dunno2=DATA(value,**{'sizeinbytes': 15}) 
2006   
2007 -    def __delfield_dunno2(self): del self.__field_dunno2 
2008   
2009      dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None) 
2010   
2011 -    def __getfield_callback(self): 
2012          return self.__field_callback.getvalue() 
2013   
2014 -    def __setfield_callback(self, value): 
2015          if isinstance(value,USTRING): 
2016              self.__field_callback=value 
2017          else: 
2018              self.__field_callback=USTRING(value,**{'sizeinbytes': 20}) 
2019   
2020 -    def __delfield_callback(self): del self.__field_callback 
2021   
2022      callback=property(__getfield_callback, __setfield_callback, __delfield_callback, None) 
2023   
2024 -    def __getfield_msg(self): 
2025          return self.__field_msg.getvalue() 
2026   
2027 -    def __setfield_msg(self, value): 
2028          if isinstance(value,USTRING): 
2029              self.__field_msg=value 
2030          else: 
2031              self.__field_msg=USTRING(value,**{'sizeinbytes': 160, 'encoding': PHONE_ENCODING}) 
2032   
2033 -    def __delfield_msg(self): del self.__field_msg 
2034   
2035      msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None) 
2036   
2037 -    def __getfield_recipients(self): 
2038          try: self.__field_recipients 
2039          except: 
2040              self.__field_recipients=LIST(**{'elementclass': recipient_record, 'length': 10}) 
2041          return self.__field_recipients.getvalue() 
2042   
2043 -    def __setfield_recipients(self, value): 
2044          if isinstance(value,LIST): 
2045              self.__field_recipients=value 
2046          else: 
2047              self.__field_recipients=LIST(value,**{'elementclass': recipient_record, 'length': 10}) 
2048   
2049 -    def __delfield_recipients(self): del self.__field_recipients 
2050   
2051      recipients=property(__getfield_recipients, __setfield_recipients, __delfield_recipients, None) 
2052   
2053 -    def iscontainer(self): 
2054          return True 
2055   
2056 -    def containerelements(self): 
2057          yield ('index', self.__field_index, None) 
2058          yield ('locked', self.__field_locked, None) 
2059          yield ('unknown1', self.__field_unknown1, None) 
2060          yield ('timesent', self.__field_timesent, None) 
2061          yield ('dunno1', self.__field_dunno1, None) 
2062          yield ('saved', self.__field_saved, None) 
2063          yield ('dunno2', self.__field_dunno2, None) 
2064          yield ('priority', self.__field_priority, "0=normal, 1=urgent") 
2065          yield ('dunno2', self.__field_dunno2, None) 
2066          yield ('callback', self.__field_callback, None) 
2067          yield ('msg', self.__field_msg, None) 
2068          yield ('recipients', self.__field_recipients, None) 
2069   
2070   
2071   
2072   
2073 -class SMSINBOXMSGFRAGMENT(BaseProtogenClass): 
2074      __fields=['msg'] 
2075   
2076 -    def __init__(self, *args, **kwargs): 
2077          dict={} 
2078          # What was supplied to this function 
2079          dict.update(kwargs) 
2080          # Parent constructor 
2081          super(SMSINBOXMSGFRAGMENT,self).__init__(**dict) 
2082          if self.__class__ is SMSINBOXMSGFRAGMENT: 
2083              self._update(args,dict) 
2084   
2085   
2086 -    def getfields(self): 
2087          return self.__fields 
2088   
2089   
2090 -    def _update(self, args, kwargs): 
2091          super(SMSINBOXMSGFRAGMENT,self)._update(args,kwargs) 
2092          keys=kwargs.keys() 
2093          for key in keys: 
2094              if key in self.__fields: 
2095                  setattr(self, key, kwargs[key]) 
2096                  del kwargs[key] 
2097          # Were any unrecognized kwargs passed in? 
2098          if __debug__: 
2099              self._complainaboutunusedargs(SMSINBOXMSGFRAGMENT,kwargs) 
2100          if len(args): 
2101              dict2={'elementclass': _gen_p_lglx570_191, 'length': 181} 
2102              dict2.update(kwargs) 
2103              kwargs=dict2 
2104              self.__field_msg=LIST(*args,**dict2) 
2105          # Make all P fields that haven't already been constructed 
2106   
2107   
2108 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2109          'Writes this packet to the supplied buffer' 
2110          self._bufferstartoffset=buf.getcurrentoffset() 
2111          try: self.__field_msg 
2112          except: 
2113              self.__field_msg=LIST(**{'elementclass': _gen_p_lglx570_191, 'length': 181}) 
2114          self.__field_msg.writetobuffer(buf) 
2115          self._bufferendoffset=buf.getcurrentoffset() 
2116          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2117   
2118   
2119 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2120          'Reads this packet from the supplied buffer' 
2121          self._bufferstartoffset=buf.getcurrentoffset() 
2122          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2123          self.__field_msg=LIST(**{'elementclass': _gen_p_lglx570_191, 'length': 181}) 
2124          self.__field_msg.readfrombuffer(buf) 
2125          self._bufferendoffset=buf.getcurrentoffset() 
2126   
2127   
2128 -    def __getfield_msg(self): 
2129          try: self.__field_msg 
2130          except: 
2131              self.__field_msg=LIST(**{'elementclass': _gen_p_lglx570_191, 'length': 181}) 
2132          return self.__field_msg.getvalue() 
2133   
2134 -    def __setfield_msg(self, value): 
2135          if isinstance(value,LIST): 
2136              self.__field_msg=value 
2137          else: 
2138              self.__field_msg=LIST(value,**{'elementclass': _gen_p_lglx570_191, 'length': 181}) 
2139   
2140 -    def __delfield_msg(self): del self.__field_msg 
2141   
2142      msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None) 
2143   
2144 -    def iscontainer(self): 
2145          return True 
2146   
2147 -    def containerelements(self): 
2148          yield ('msg', self.__field_msg, None) 
2149   
2150   
2151   
2152   
2153 -class _gen_p_lglx570_191(BaseProtogenClass): 
2154      'Anonymous inner class' 
2155      __fields=['byte'] 
2156   
2157 -    def __init__(self, *args, **kwargs): 
2158          dict={} 
2159          # What was supplied to this function 
2160          dict.update(kwargs) 
2161          # Parent constructor 
2162          super(_gen_p_lglx570_191,self).__init__(**dict) 
2163          if self.__class__ is _gen_p_lglx570_191: 
2164              self._update(args,dict) 
2165   
2166   
2167 -    def getfields(self): 
2168          return self.__fields 
2169   
2170   
2171 -    def _update(self, args, kwargs): 
2172          super(_gen_p_lglx570_191,self)._update(args,kwargs) 
2173          keys=kwargs.keys() 
2174          for key in keys: 
2175              if key in self.__fields: 
2176                  setattr(self, key, kwargs[key]) 
2177                  del kwargs[key] 
2178          # Were any unrecognized kwargs passed in? 
2179          if __debug__: 
2180              self._complainaboutunusedargs(_gen_p_lglx570_191,kwargs) 
2181          if len(args): 
2182              dict2={'sizeinbytes': 1} 
2183              dict2.update(kwargs) 
2184              kwargs=dict2 
2185              self.__field_byte=UINT(*args,**dict2) 
2186          # Make all P fields that haven't already been constructed 
2187   
2188   
2189 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2190          'Writes this packet to the supplied buffer' 
2191          self._bufferstartoffset=buf.getcurrentoffset() 
2192          self.__field_byte.writetobuffer(buf) 
2193          self._bufferendoffset=buf.getcurrentoffset() 
2194          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2195   
2196   
2197 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2198          'Reads this packet from the supplied buffer' 
2199          self._bufferstartoffset=buf.getcurrentoffset() 
2200          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2201          self.__field_byte=UINT(**{'sizeinbytes': 1}) 
2202          self.__field_byte.readfrombuffer(buf) 
2203          self._bufferendoffset=buf.getcurrentoffset() 
2204   
2205   
2206 -    def __getfield_byte(self): 
2207          return self.__field_byte.getvalue() 
2208   
2209 -    def __setfield_byte(self, value): 
2210          if isinstance(value,UINT): 
2211              self.__field_byte=value 
2212          else: 
2213              self.__field_byte=UINT(value,**{'sizeinbytes': 1}) 
2214   
2215 -    def __delfield_byte(self): del self.__field_byte 
2216   
2217      byte=property(__getfield_byte, __setfield_byte, __delfield_byte, "individual byte of message") 
2218   
2219 -    def iscontainer(self): 
2220          return True 
2221   
2222 -    def containerelements(self): 
2223          yield ('byte', self.__field_byte, "individual byte of message") 
2224   
2225   
2226   
2227   
2228 -class sms_in(BaseProtogenClass): 
2229      __fields=['unknown1', 'msg_index2', 'unknown2', 'timesent', 'unknown', 'callback_length', 'callback', 'sender_length', 'sender', 'unknown4', 'lg_time', 'GPStime', 'dunno1', 'read', 'locked', 'unknown5', 'subject', 'msglength', 'msg'] 
2230   
2231 -    def __init__(self, *args, **kwargs): 
2232          dict={} 
2233          # What was supplied to this function 
2234          dict.update(kwargs) 
2235          # Parent constructor 
2236          super(sms_in,self).__init__(**dict) 
2237          if self.__class__ is sms_in: 
2238              self._update(args,dict) 
2239   
2240   
2241 -    def getfields(self): 
2242          return self.__fields 
2243   
2244   
2245 -    def _update(self, args, kwargs): 
2246          super(sms_in,self)._update(args,kwargs) 
2247          keys=kwargs.keys() 
2248          for key in keys: 
2249              if key in self.__fields: 
2250                  setattr(self, key, kwargs[key]) 
2251                  del kwargs[key] 
2252          # Were any unrecognized kwargs passed in? 
2253          if __debug__: 
2254              self._complainaboutunusedargs(sms_in,kwargs) 
2255          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2256          # Make all P fields that haven't already been constructed 
2257   
2258   
2259 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2260          'Writes this packet to the supplied buffer' 
2261          self._bufferstartoffset=buf.getcurrentoffset() 
2262          self.__field_unknown1.writetobuffer(buf) 
2263          self.__field_msg_index2.writetobuffer(buf) 
2264          self.__field_unknown2.writetobuffer(buf) 
2265          self.__field_timesent.writetobuffer(buf) 
2266          self.__field_unknown.writetobuffer(buf) 
2267          self.__field_callback_length.writetobuffer(buf) 
2268          self.__field_callback.writetobuffer(buf) 
2269          self.__field_sender_length.writetobuffer(buf) 
2270          try: self.__field_sender 
2271          except: 
2272              self.__field_sender=LIST(**{'elementclass': _gen_p_lglx570_203, 'length': 38}) 
2273          self.__field_sender.writetobuffer(buf) 
2274          self.__field_unknown4.writetobuffer(buf) 
2275          self.__field_lg_time.writetobuffer(buf) 
2276          self.__field_GPStime.writetobuffer(buf) 
2277          self.__field_dunno1.writetobuffer(buf) 
2278          self.__field_read.writetobuffer(buf) 
2279          self.__field_locked.writetobuffer(buf) 
2280          self.__field_unknown5.writetobuffer(buf) 
2281          self.__field_subject.writetobuffer(buf) 
2282          self.__field_msglength.writetobuffer(buf) 
2283          self.__field_msg.writetobuffer(buf) 
2284          self._bufferendoffset=buf.getcurrentoffset() 
2285          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2286   
2287   
2288 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2289          'Reads this packet from the supplied buffer' 
2290          self._bufferstartoffset=buf.getcurrentoffset() 
2291          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2292          self.__field_unknown1=UINT(**{'sizeinbytes': 4}) 
2293          self.__field_unknown1.readfrombuffer(buf) 
2294          self.__field_msg_index2=UINT(**{'sizeinbytes': 4}) 
2295          self.__field_msg_index2.readfrombuffer(buf) 
2296          self.__field_unknown2=UINT(**{'sizeinbytes': 2}) 
2297          self.__field_unknown2.readfrombuffer(buf) 
2298          self.__field_timesent=SMSDATE(**{'sizeinbytes': 6}) 
2299          self.__field_timesent.readfrombuffer(buf) 
2300          self.__field_unknown=UINT(**{'sizeinbytes': 3}) 
2301          self.__field_unknown.readfrombuffer(buf) 
2302          self.__field_callback_length=UINT(**{'sizeinbytes': 1}) 
2303          self.__field_callback_length.readfrombuffer(buf) 
2304          self.__field_callback=USTRING(**{'sizeinbytes': 42}) 
2305          self.__field_callback.readfrombuffer(buf) 
2306          self.__field_sender_length=UINT(**{'sizeinbytes': 1}) 
2307          self.__field_sender_length.readfrombuffer(buf) 
2308          self.__field_sender=LIST(**{'elementclass': _gen_p_lglx570_203, 'length': 38}) 
2309          self.__field_sender.readfrombuffer(buf) 
2310          self.__field_unknown4=DATA(**{'sizeinbytes': 15}) 
2311          self.__field_unknown4.readfrombuffer(buf) 
2312          self.__field_lg_time=LGCALDATE(**{'sizeinbytes': 4}) 
2313          self.__field_lg_time.readfrombuffer(buf) 
2314          self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4}) 
2315          self.__field_GPStime.readfrombuffer(buf) 
2316          self.__field_dunno1=DATA(**{'sizeinbytes': 5}) 
2317          self.__field_dunno1.readfrombuffer(buf) 
2318          self.__field_read=UINT(**{'sizeinbytes': 1}) 
2319          self.__field_read.readfrombuffer(buf) 
2320          self.__field_locked=UINT(**{'sizeinbytes': 1}) 
2321          self.__field_locked.readfrombuffer(buf) 
2322          self.__field_unknown5=DATA(**{'sizeinbytes': 7}) 
2323          self.__field_unknown5.readfrombuffer(buf) 
2324          self.__field_subject=USTRING(**{'sizeinbytes': 74, 'encoding': PHONE_ENCODING}) 
2325          self.__field_subject.readfrombuffer(buf) 
2326          self.__field_msglength=UINT(**{'sizeinbytes': 2}) 
2327          self.__field_msglength.readfrombuffer(buf) 
2328          self.__field_msg=USTRING(**{'sizeinbytes': 1030, 'encoding': PHONE_ENCODING}) 
2329          self.__field_msg.readfrombuffer(buf) 
2330          self._bufferendoffset=buf.getcurrentoffset() 
2331   
2332   
2333 -    def __getfield_unknown1(self): 
2334          return self.__field_unknown1.getvalue() 
2335   
2336 -    def __setfield_unknown1(self, value): 
2337          if isinstance(value,UINT): 
2338              self.__field_unknown1=value 
2339          else: 
2340              self.__field_unknown1=UINT(value,**{'sizeinbytes': 4}) 
2341   
2342 -    def __delfield_unknown1(self): del self.__field_unknown1 
2343   
2344      unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 
2345   
2346 -    def __getfield_msg_index2(self): 
2347          return self.__field_msg_index2.getvalue() 
2348   
2349 -    def __setfield_msg_index2(self, value): 
2350          if isinstance(value,UINT): 
2351              self.__field_msg_index2=value 
2352          else: 
2353              self.__field_msg_index2=UINT(value,**{'sizeinbytes': 4}) 
2354   
2355 -    def __delfield_msg_index2(self): del self.__field_msg_index2 
2356   
2357      msg_index2=property(__getfield_msg_index2, __setfield_msg_index2, __delfield_msg_index2, None) 
2358   
2359 -    def __getfield_unknown2(self): 
2360          return self.__field_unknown2.getvalue() 
2361   
2362 -    def __setfield_unknown2(self, value): 
2363          if isinstance(value,UINT): 
2364              self.__field_unknown2=value 
2365          else: 
2366              self.__field_unknown2=UINT(value,**{'sizeinbytes': 2}) 
2367   
2368 -    def __delfield_unknown2(self): del self.__field_unknown2 
2369   
2370      unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None) 
2371   
2372 -    def __getfield_timesent(self): 
2373          return self.__field_timesent.getvalue() 
2374   
2375 -    def __setfield_timesent(self, value): 
2376          if isinstance(value,SMSDATE): 
2377              self.__field_timesent=value 
2378          else: 
2379              self.__field_timesent=SMSDATE(value,**{'sizeinbytes': 6}) 
2380   
2381 -    def __delfield_timesent(self): del self.__field_timesent 
2382   
2383      timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None) 
2384   
2385 -    def __getfield_unknown(self): 
2386          return self.__field_unknown.getvalue() 
2387   
2388 -    def __setfield_unknown(self, value): 
2389          if isinstance(value,UINT): 
2390              self.__field_unknown=value 
2391          else: 
2392              self.__field_unknown=UINT(value,**{'sizeinbytes': 3}) 
2393   
2394 -    def __delfield_unknown(self): del self.__field_unknown 
2395   
2396      unknown=property(__getfield_unknown, __setfield_unknown, __delfield_unknown, None) 
2397   
2398 -    def __getfield_callback_length(self): 
2399          return self.__field_callback_length.getvalue() 
2400   
2401 -    def __setfield_callback_length(self, value): 
2402          if isinstance(value,UINT): 
2403              self.__field_callback_length=value 
2404          else: 
2405              self.__field_callback_length=UINT(value,**{'sizeinbytes': 1}) 
2406   
2407 -    def __delfield_callback_length(self): del self.__field_callback_length 
2408   
2409      callback_length=property(__getfield_callback_length, __setfield_callback_length, __delfield_callback_length, None) 
2410   
2411 -    def __getfield_callback(self): 
2412          return self.__field_callback.getvalue() 
2413   
2414 -    def __setfield_callback(self, value): 
2415          if isinstance(value,USTRING): 
2416              self.__field_callback=value 
2417          else: 
2418              self.__field_callback=USTRING(value,**{'sizeinbytes': 42}) 
2419   
2420 -    def __delfield_callback(self): del self.__field_callback 
2421   
2422      callback=property(__getfield_callback, __setfield_callback, __delfield_callback, None) 
2423   
2424 -    def __getfield_sender_length(self): 
2425          return self.__field_sender_length.getvalue() 
2426   
2427 -    def __setfield_sender_length(self, value): 
2428          if isinstance(value,UINT): 
2429              self.__field_sender_length=value 
2430          else: 
2431              self.__field_sender_length=UINT(value,**{'sizeinbytes': 1}) 
2432   
2433 -    def __delfield_sender_length(self): del self.__field_sender_length 
2434   
2435      sender_length=property(__getfield_sender_length, __setfield_sender_length, __delfield_sender_length, None) 
2436   
2437 -    def __getfield_sender(self): 
2438          try: self.__field_sender 
2439          except: 
2440              self.__field_sender=LIST(**{'elementclass': _gen_p_lglx570_203, 'length': 38}) 
2441          return self.__field_sender.getvalue() 
2442   
2443 -    def __setfield_sender(self, value): 
2444          if isinstance(value,LIST): 
2445              self.__field_sender=value 
2446          else: 
2447              self.__field_sender=LIST(value,**{'elementclass': _gen_p_lglx570_203, 'length': 38}) 
2448   
2449 -    def __delfield_sender(self): del self.__field_sender 
2450   
2451      sender=property(__getfield_sender, __setfield_sender, __delfield_sender, None) 
2452   
2453 -    def __getfield_unknown4(self): 
2454          return self.__field_unknown4.getvalue() 
2455   
2456 -    def __setfield_unknown4(self, value): 
2457          if isinstance(value,DATA): 
2458              self.__field_unknown4=value 
2459          else: 
2460              self.__field_unknown4=DATA(value,**{'sizeinbytes': 15}) 
2461   
2462 -    def __delfield_unknown4(self): del self.__field_unknown4 
2463   
2464      unknown4=property(__getfield_unknown4, __setfield_unknown4, __delfield_unknown4, None) 
2465   
2466 -    def __getfield_lg_time(self): 
2467          return self.__field_lg_time.getvalue() 
2468   
2469 -    def __setfield_lg_time(self, value): 
2470          if isinstance(value,LGCALDATE): 
2471              self.__field_lg_time=value 
2472          else: 
2473              self.__field_lg_time=LGCALDATE(value,**{'sizeinbytes': 4}) 
2474   
2475 -    def __delfield_lg_time(self): del self.__field_lg_time 
2476   
2477      lg_time=property(__getfield_lg_time, __setfield_lg_time, __delfield_lg_time, None) 
2478   
2479 -    def __getfield_GPStime(self): 
2480          return self.__field_GPStime.getvalue() 
2481   
2482 -    def __setfield_GPStime(self, value): 
2483          if isinstance(value,GPSDATE): 
2484              self.__field_GPStime=value 
2485          else: 
2486              self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4}) 
2487   
2488 -    def __delfield_GPStime(self): del self.__field_GPStime 
2489   
2490      GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None) 
2491   
2492 -    def __getfield_dunno1(self): 
2493          return self.__field_dunno1.getvalue() 
2494   
2495 -    def __setfield_dunno1(self, value): 
2496          if isinstance(value,DATA): 
2497              self.__field_dunno1=value 
2498          else: 
2499              self.__field_dunno1=DATA(value,**{'sizeinbytes': 5}) 
2500   
2501 -    def __delfield_dunno1(self): del self.__field_dunno1 
2502   
2503      dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None) 
2504   
2505 -    def __getfield_read(self): 
2506          return self.__field_read.getvalue() 
2507   
2508 -    def __setfield_read(self, value): 
2509          if isinstance(value,UINT): 
2510              self.__field_read=value 
2511          else: 
2512              self.__field_read=UINT(value,**{'sizeinbytes': 1}) 
2513   
2514 -    def __delfield_read(self): del self.__field_read 
2515   
2516      read=property(__getfield_read, __setfield_read, __delfield_read, None) 
2517   
2518 -    def __getfield_locked(self): 
2519          return self.__field_locked.getvalue() 
2520   
2521 -    def __setfield_locked(self, value): 
2522          if isinstance(value,UINT): 
2523              self.__field_locked=value 
2524          else: 
2525              self.__field_locked=UINT(value,**{'sizeinbytes': 1}) 
2526   
2527 -    def __delfield_locked(self): del self.__field_locked 
2528   
2529      locked=property(__getfield_locked, __setfield_locked, __delfield_locked, None) 
2530   
2531 -    def __getfield_unknown5(self): 
2532          return self.__field_unknown5.getvalue() 
2533   
2534 -    def __setfield_unknown5(self, value): 
2535          if isinstance(value,DATA): 
2536              self.__field_unknown5=value 
2537          else: 
2538              self.__field_unknown5=DATA(value,**{'sizeinbytes': 7}) 
2539   
2540 -    def __delfield_unknown5(self): del self.__field_unknown5 
2541   
2542      unknown5=property(__getfield_unknown5, __setfield_unknown5, __delfield_unknown5, None) 
2543   
2544 -    def __getfield_subject(self): 
2545          return self.__field_subject.getvalue() 
2546   
2547 -    def __setfield_subject(self, value): 
2548          if isinstance(value,USTRING): 
2549              self.__field_subject=value 
2550          else: 
2551              self.__field_subject=USTRING(value,**{'sizeinbytes': 74, 'encoding': PHONE_ENCODING}) 
2552   
2553 -    def __delfield_subject(self): del self.__field_subject 
2554   
2555      subject=property(__getfield_subject, __setfield_subject, __delfield_subject, None) 
2556   
2557 -    def __getfield_msglength(self): 
2558          return self.__field_msglength.getvalue() 
2559   
2560 -    def __setfield_msglength(self, value): 
2561          if isinstance(value,UINT): 
2562              self.__field_msglength=value 
2563          else: 
2564              self.__field_msglength=UINT(value,**{'sizeinbytes': 2}) 
2565   
2566 -    def __delfield_msglength(self): del self.__field_msglength 
2567   
2568      msglength=property(__getfield_msglength, __setfield_msglength, __delfield_msglength, None) 
2569   
2570 -    def __getfield_msg(self): 
2571          return self.__field_msg.getvalue() 
2572   
2573 -    def __setfield_msg(self, value): 
2574          if isinstance(value,USTRING): 
2575              self.__field_msg=value 
2576          else: 
2577              self.__field_msg=USTRING(value,**{'sizeinbytes': 1030, 'encoding': PHONE_ENCODING}) 
2578   
2579 -    def __delfield_msg(self): del self.__field_msg 
2580   
2581      msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None) 
2582   
2583 -    def iscontainer(self): 
2584          return True 
2585   
2586 -    def containerelements(self): 
2587          yield ('unknown1', self.__field_unknown1, None) 
2588          yield ('msg_index2', self.__field_msg_index2, None) 
2589          yield ('unknown2', self.__field_unknown2, None) 
2590          yield ('timesent', self.__field_timesent, None) 
2591          yield ('unknown', self.__field_unknown, None) 
2592          yield ('callback_length', self.__field_callback_length, None) 
2593          yield ('callback', self.__field_callback, None) 
2594          yield ('sender_length', self.__field_sender_length, None) 
2595          yield ('sender', self.__field_sender, None) 
2596          yield ('unknown4', self.__field_unknown4, None) 
2597          yield ('lg_time', self.__field_lg_time, None) 
2598          yield ('GPStime', self.__field_GPStime, None) 
2599          yield ('dunno1', self.__field_dunno1, None) 
2600          yield ('read', self.__field_read, None) 
2601          yield ('locked', self.__field_locked, None) 
2602          yield ('unknown5', self.__field_unknown5, None) 
2603          yield ('subject', self.__field_subject, None) 
2604          yield ('msglength', self.__field_msglength, None) 
2605          yield ('msg', self.__field_msg, None) 
2606   
2607   
2608   
2609   
2610 -class _gen_p_lglx570_203(BaseProtogenClass): 
2611      'Anonymous inner class' 
2612      __fields=['byte'] 
2613   
2614 -    def __init__(self, *args, **kwargs): 
2615          dict={} 
2616          # What was supplied to this function 
2617          dict.update(kwargs) 
2618          # Parent constructor 
2619          super(_gen_p_lglx570_203,self).__init__(**dict) 
2620          if self.__class__ is _gen_p_lglx570_203: 
2621              self._update(args,dict) 
2622   
2623   
2624 -    def getfields(self): 
2625          return self.__fields 
2626   
2627   
2628 -    def _update(self, args, kwargs): 
2629          super(_gen_p_lglx570_203,self)._update(args,kwargs) 
2630          keys=kwargs.keys() 
2631          for key in keys: 
2632              if key in self.__fields: 
2633                  setattr(self, key, kwargs[key]) 
2634                  del kwargs[key] 
2635          # Were any unrecognized kwargs passed in? 
2636          if __debug__: 
2637              self._complainaboutunusedargs(_gen_p_lglx570_203,kwargs) 
2638          if len(args): 
2639              dict2={'sizeinbytes': 1} 
2640              dict2.update(kwargs) 
2641              kwargs=dict2 
2642              self.__field_byte=UINT(*args,**dict2) 
2643          # Make all P fields that haven't already been constructed 
2644   
2645   
2646 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2647          'Writes this packet to the supplied buffer' 
2648          self._bufferstartoffset=buf.getcurrentoffset() 
2649          self.__field_byte.writetobuffer(buf) 
2650          self._bufferendoffset=buf.getcurrentoffset() 
2651          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2652   
2653   
2654 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2655          'Reads this packet from the supplied buffer' 
2656          self._bufferstartoffset=buf.getcurrentoffset() 
2657          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2658          self.__field_byte=UINT(**{'sizeinbytes': 1}) 
2659          self.__field_byte.readfrombuffer(buf) 
2660          self._bufferendoffset=buf.getcurrentoffset() 
2661   
2662   
2663 -    def __getfield_byte(self): 
2664          return self.__field_byte.getvalue() 
2665   
2666 -    def __setfield_byte(self, value): 
2667          if isinstance(value,UINT): 
2668              self.__field_byte=value 
2669          else: 
2670              self.__field_byte=UINT(value,**{'sizeinbytes': 1}) 
2671   
2672 -    def __delfield_byte(self): del self.__field_byte 
2673   
2674      byte=property(__getfield_byte, __setfield_byte, __delfield_byte, "individual byte of senders phone number") 
2675   
2676 -    def iscontainer(self): 
2677          return True 
2678   
2679 -    def containerelements(self): 
2680          yield ('byte', self.__field_byte, "individual byte of senders phone number") 
2681   
2682   
2683   
2684   
2685 -class sms_quick_text(BaseProtogenClass): 
2686      __fields=['msg'] 
2687   
2688 -    def __init__(self, *args, **kwargs): 
2689          dict={} 
2690          # What was supplied to this function 
2691          dict.update(kwargs) 
2692          # Parent constructor 
2693          super(sms_quick_text,self).__init__(**dict) 
2694          if self.__class__ is sms_quick_text: 
2695              self._update(args,dict) 
2696   
2697   
2698 -    def getfields(self): 
2699          return self.__fields 
2700   
2701   
2702 -    def _update(self, args, kwargs): 
2703          super(sms_quick_text,self)._update(args,kwargs) 
2704          keys=kwargs.keys() 
2705          for key in keys: 
2706              if key in self.__fields: 
2707                  setattr(self, key, kwargs[key]) 
2708                  del kwargs[key] 
2709          # Were any unrecognized kwargs passed in? 
2710          if __debug__: 
2711              self._complainaboutunusedargs(sms_quick_text,kwargs) 
2712          if len(args): 
2713              dict2={'sizeinbytes': 101, 'encoding': PHONE_ENCODING,                 'default': ""} 
2714              dict2.update(kwargs) 
2715              kwargs=dict2 
2716              self.__field_msg=USTRING(*args,**dict2) 
2717          # Make all P fields that haven't already been constructed 
2718   
2719   
2720 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2721          'Writes this packet to the supplied buffer' 
2722          self._bufferstartoffset=buf.getcurrentoffset() 
2723          try: self.__field_msg 
2724          except: 
2725              self.__field_msg=USTRING(**{'sizeinbytes': 101, 'encoding': PHONE_ENCODING,                 'default': ""}) 
2726          self.__field_msg.writetobuffer(buf) 
2727          self._bufferendoffset=buf.getcurrentoffset() 
2728          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2729   
2730   
2731 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2732          'Reads this packet from the supplied buffer' 
2733          self._bufferstartoffset=buf.getcurrentoffset() 
2734          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2735          self.__field_msg=USTRING(**{'sizeinbytes': 101, 'encoding': PHONE_ENCODING,                 'default': ""}) 
2736          self.__field_msg.readfrombuffer(buf) 
2737          self._bufferendoffset=buf.getcurrentoffset() 
2738   
2739   
2740 -    def __getfield_msg(self): 
2741          try: self.__field_msg 
2742          except: 
2743              self.__field_msg=USTRING(**{'sizeinbytes': 101, 'encoding': PHONE_ENCODING,                 'default': ""}) 
2744          return self.__field_msg.getvalue() 
2745   
2746 -    def __setfield_msg(self, value): 
2747          if isinstance(value,USTRING): 
2748              self.__field_msg=value 
2749          else: 
2750              self.__field_msg=USTRING(value,**{'sizeinbytes': 101, 'encoding': PHONE_ENCODING,                 'default': ""}) 
2751   
2752 -    def __delfield_msg(self): del self.__field_msg 
2753   
2754      msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None) 
2755   
2756 -    def iscontainer(self): 
2757          return True 
2758   
2759 -    def containerelements(self): 
2760          yield ('msg', self.__field_msg, None) 
2761   
2762   
2763   
2764   
2765 -class sms_canned_file(BaseProtogenClass): 
2766      __fields=['num_active', 'msgs'] 
2767   
2768 -    def __init__(self, *args, **kwargs): 
2769          dict={} 
2770          # What was supplied to this function 
2771          dict.update(kwargs) 
2772          # Parent constructor 
2773          super(sms_canned_file,self).__init__(**dict) 
2774          if self.__class__ is sms_canned_file: 
2775              self._update(args,dict) 
2776   
2777   
2778 -    def getfields(self): 
2779          return self.__fields 
2780   
2781   
2782 -    def _update(self, args, kwargs): 
2783          super(sms_canned_file,self)._update(args,kwargs) 
2784          keys=kwargs.keys() 
2785          for key in keys: 
2786              if key in self.__fields: 
2787                  setattr(self, key, kwargs[key]) 
2788                  del kwargs[key] 
2789          # Were any unrecognized kwargs passed in? 
2790          if __debug__: 
2791              self._complainaboutunusedargs(sms_canned_file,kwargs) 
2792          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2793          # Make all P fields that haven't already been constructed 
2794   
2795   
2796 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2797          'Writes this packet to the supplied buffer' 
2798          self._bufferstartoffset=buf.getcurrentoffset() 
2799          try: self.__field_num_active 
2800          except: 
2801              self.__field_num_active=UINT(**{'sizeinbytes': 2,  'default': len(self.msgs) }) 
2802          self.__field_num_active.writetobuffer(buf) 
2803          try: self.__field_msgs 
2804          except: 
2805              self.__field_msgs=LIST(**{'length': SMS_CANNED_MAX_ITEMS,            'createdefault': True,            'elementclass': sms_quick_text}) 
2806          self.__field_msgs.writetobuffer(buf) 
2807          self._bufferendoffset=buf.getcurrentoffset() 
2808          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2809   
2810   
2811 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2812          'Reads this packet from the supplied buffer' 
2813          self._bufferstartoffset=buf.getcurrentoffset() 
2814          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2815          self.__field_num_active=UINT(**{'sizeinbytes': 2,  'default': len(self.msgs) }) 
2816          self.__field_num_active.readfrombuffer(buf) 
2817          self.__field_msgs=LIST(**{'length': SMS_CANNED_MAX_ITEMS,            'createdefault': True,            'elementclass': sms_quick_text}) 
2818          self.__field_msgs.readfrombuffer(buf) 
2819          self._bufferendoffset=buf.getcurrentoffset() 
2820   
2821   
2822 -    def __getfield_num_active(self): 
2823          try: self.__field_num_active 
2824          except: 
2825              self.__field_num_active=UINT(**{'sizeinbytes': 2,  'default': len(self.msgs) }) 
2826          return self.__field_num_active.getvalue() 
2827   
2828 -    def __setfield_num_active(self, value): 
2829          if isinstance(value,UINT): 
2830              self.__field_num_active=value 
2831          else: 
2832              self.__field_num_active=UINT(value,**{'sizeinbytes': 2,  'default': len(self.msgs) }) 
2833   
2834 -    def __delfield_num_active(self): del self.__field_num_active 
2835   
2836      num_active=property(__getfield_num_active, __setfield_num_active, __delfield_num_active, None) 
2837   
2838 -    def __getfield_msgs(self): 
2839          try: self.__field_msgs 
2840          except: 
2841              self.__field_msgs=LIST(**{'length': SMS_CANNED_MAX_ITEMS,            'createdefault': True,            'elementclass': sms_quick_text}) 
2842          return self.__field_msgs.getvalue() 
2843   
2844 -    def __setfield_msgs(self, value): 
2845          if isinstance(value,LIST): 
2846              self.__field_msgs=value 
2847          else: 
2848              self.__field_msgs=LIST(value,**{'length': SMS_CANNED_MAX_ITEMS,            'createdefault': True,            'elementclass': sms_quick_text}) 
2849   
2850 -    def __delfield_msgs(self): del self.__field_msgs 
2851   
2852      msgs=property(__getfield_msgs, __setfield_msgs, __delfield_msgs, None) 
2853   
2854 -    def iscontainer(self): 
2855          return True 
2856   
2857 -    def containerelements(self): 
2858          yield ('num_active', self.__field_num_active, None) 
2859          yield ('msgs', self.__field_msgs, None) 
2860