Source Code for Module phones.p_lgvx8500

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