Source Code for Module phones.p_lgvx6000

   1  # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE 
   2   
   3  """Various descriptions of data specific to LG VX6000""" 
   4   
   5  from prototypes import * 
   6   
   7  # Make all lg stuff available in this module as well 
   8  from p_lg import * 
   9   
  10  # we are the same as lgvx4400 except as noted 
  11  # below 
  12  from p_lgvx4400 import * 
  13   
  14  # We use LSB for all integer like fields 
  15  UINT=UINTlsb 
  16  BOOL=BOOLlsb 
  17   
  18  NUMSPEEDDIALS=100 
  19  FIRSTSPEEDDIAL=2 
  20  LASTSPEEDDIAL=99 
  21  NUMPHONEBOOKENTRIES=500 
  22  MAXCALENDARDESCRIPTION=38 
  23   
  24  # Calendar parameters 
  25  NUMCALENDARENTRIES=300 
  26  CAL_REP_NONE=0x10 
  27  CAL_REP_DAILY=0x11 
  28  CAL_REP_MONFRI=0x12 
  29  CAL_REP_WEEKLY=0x13 
  30  CAL_REP_MONTHLY=0x14 
  31  CAL_REP_YEARLY=0x15 
  32  CAL_DOW_SUN=0x0800 
  33  CAL_DOW_MON=0x0400 
  34  CAL_DOW_TUE=0x0200 
  35  CAL_DOW_WED=0x0100 
  36  CAL_DOW_THU=0x0080 
  37  CAL_DOW_FRI=0x0040 
  38  CAL_DOW_SAT=0x0020 
  39  CAL_DOW_EXCEPTIONS=0x0010 
  40  CAL_REMINDER_NONE=0 
  41  CAL_REMINDER_ONTIME=1 
  42  CAL_REMINDER_5MIN=2 
  43  CAL_REMINDER_10MIN=3 
  44  CAL_REMINDER_1HOUR=4 
  45  CAL_REMINDER_1DAY=5 
  46  CAL_REMINDER_2DAYS=6 
  47  CAL_REPEAT_DATE=(2100, 12, 31) 
  48   
  49  cal_dir='sch' 
  50  cal_data_file_name='sch/schedule.dat' 
  51  cal_exception_file_name='sch/schexception.dat' 
  52  cal_has_voice_id=False 
  53   
  54 -class speeddial(BaseProtogenClass): 
  55      __fields=['entry', 'number'] 
  56   
  57 -    def __init__(self, *args, **kwargs): 
  58          dict={} 
  59          # What was supplied to this function 
  60          dict.update(kwargs) 
  61          # Parent constructor 
  62          super(speeddial,self).__init__(**dict) 
  63          if self.__class__ is speeddial: 
  64              self._update(args,dict) 
  65   
  66   
  67 -    def getfields(self): 
  68          return self.__fields 
  69   
  70   
  71 -    def _update(self, args, kwargs): 
  72          super(speeddial,self)._update(args,kwargs) 
  73          keys=kwargs.keys() 
  74          for key in keys: 
  75              if key in self.__fields: 
  76                  setattr(self, key, kwargs[key]) 
  77                  del kwargs[key] 
  78          # Were any unrecognized kwargs passed in? 
  79          if __debug__: 
  80              self._complainaboutunusedargs(speeddial,kwargs) 
  81          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
  82          # Make all P fields that haven't already been constructed 
  83   
  84   
  85 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
  86          'Writes this packet to the supplied buffer' 
  87          self._bufferstartoffset=buf.getcurrentoffset() 
  88          try: self.__field_entry 
  89          except: 
  90              self.__field_entry=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
  91          self.__field_entry.writetobuffer(buf) 
  92          try: self.__field_number 
  93          except: 
  94              self.__field_number=UINT(**{'sizeinbytes': 1, 'default': 0xff}) 
  95          self.__field_number.writetobuffer(buf) 
  96          self._bufferendoffset=buf.getcurrentoffset() 
  97          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
  98   
  99   
 100 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 101          'Reads this packet from the supplied buffer' 
 102          self._bufferstartoffset=buf.getcurrentoffset() 
 103          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 104          self.__field_entry=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
 105          self.__field_entry.readfrombuffer(buf) 
 106          self.__field_number=UINT(**{'sizeinbytes': 1, 'default': 0xff}) 
 107          self.__field_number.readfrombuffer(buf) 
 108          self._bufferendoffset=buf.getcurrentoffset() 
 109   
 110   
 111 -    def __getfield_entry(self): 
 112          try: self.__field_entry 
 113          except: 
 114              self.__field_entry=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
 115          return self.__field_entry.getvalue() 
 116   
 117 -    def __setfield_entry(self, value): 
 118          if isinstance(value,UINT): 
 119              self.__field_entry=value 
 120          else: 
 121              self.__field_entry=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff}) 
 122   
 123 -    def __delfield_entry(self): del self.__field_entry 
 124   
 125      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
 126   
 127 -    def __getfield_number(self): 
 128          try: self.__field_number 
 129          except: 
 130              self.__field_number=UINT(**{'sizeinbytes': 1, 'default': 0xff}) 
 131          return self.__field_number.getvalue() 
 132   
 133 -    def __setfield_number(self, value): 
 134          if isinstance(value,UINT): 
 135              self.__field_number=value 
 136          else: 
 137              self.__field_number=UINT(value,**{'sizeinbytes': 1, 'default': 0xff}) 
 138   
 139 -    def __delfield_number(self): del self.__field_number 
 140   
 141      number=property(__getfield_number, __setfield_number, __delfield_number, None) 
 142   
 143 -    def iscontainer(self): 
 144          return True 
 145   
 146 -    def containerelements(self): 
 147          yield ('entry', self.__field_entry, None) 
 148          yield ('number', self.__field_number, None) 
 149   
 150   
 151   
 152   
 153 -class speeddials(BaseProtogenClass): 
 154      __fields=['speeddials'] 
 155   
 156 -    def __init__(self, *args, **kwargs): 
 157          dict={} 
 158          # What was supplied to this function 
 159          dict.update(kwargs) 
 160          # Parent constructor 
 161          super(speeddials,self).__init__(**dict) 
 162          if self.__class__ is speeddials: 
 163              self._update(args,dict) 
 164   
 165   
 166 -    def getfields(self): 
 167          return self.__fields 
 168   
 169   
 170 -    def _update(self, args, kwargs): 
 171          super(speeddials,self)._update(args,kwargs) 
 172          keys=kwargs.keys() 
 173          for key in keys: 
 174              if key in self.__fields: 
 175                  setattr(self, key, kwargs[key]) 
 176                  del kwargs[key] 
 177          # Were any unrecognized kwargs passed in? 
 178          if __debug__: 
 179              self._complainaboutunusedargs(speeddials,kwargs) 
 180          if len(args): 
 181              dict2={'length': NUMSPEEDDIALS, 'elementclass': speeddial} 
 182              dict2.update(kwargs) 
 183              kwargs=dict2 
 184              self.__field_speeddials=LIST(*args,**dict2) 
 185          # Make all P fields that haven't already been constructed 
 186   
 187   
 188 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 189          'Writes this packet to the supplied buffer' 
 190          self._bufferstartoffset=buf.getcurrentoffset() 
 191          try: self.__field_speeddials 
 192          except: 
 193              self.__field_speeddials=LIST(**{'length': NUMSPEEDDIALS, 'elementclass': speeddial}) 
 194          self.__field_speeddials.writetobuffer(buf) 
 195          self._bufferendoffset=buf.getcurrentoffset() 
 196          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 197   
 198   
 199 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 200          'Reads this packet from the supplied buffer' 
 201          self._bufferstartoffset=buf.getcurrentoffset() 
 202          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 203          self.__field_speeddials=LIST(**{'length': NUMSPEEDDIALS, 'elementclass': speeddial}) 
 204          self.__field_speeddials.readfrombuffer(buf) 
 205          self._bufferendoffset=buf.getcurrentoffset() 
 206   
 207   
 208 -    def __getfield_speeddials(self): 
 209          try: self.__field_speeddials 
 210          except: 
 211              self.__field_speeddials=LIST(**{'length': NUMSPEEDDIALS, 'elementclass': speeddial}) 
 212          return self.__field_speeddials.getvalue() 
 213   
 214 -    def __setfield_speeddials(self, value): 
 215          if isinstance(value,LIST): 
 216              self.__field_speeddials=value 
 217          else: 
 218              self.__field_speeddials=LIST(value,**{'length': NUMSPEEDDIALS, 'elementclass': speeddial}) 
 219   
 220 -    def __delfield_speeddials(self): del self.__field_speeddials 
 221   
 222      speeddials=property(__getfield_speeddials, __setfield_speeddials, __delfield_speeddials, None) 
 223   
 224 -    def iscontainer(self): 
 225          return True 
 226   
 227 -    def containerelements(self): 
 228          yield ('speeddials', self.__field_speeddials, None) 
 229   
 230   
 231   
 232   
 233 -class indexentry(BaseProtogenClass): 
 234      __fields=['index', 'name'] 
 235   
 236 -    def __init__(self, *args, **kwargs): 
 237          dict={} 
 238          # What was supplied to this function 
 239          dict.update(kwargs) 
 240          # Parent constructor 
 241          super(indexentry,self).__init__(**dict) 
 242          if self.__class__ is indexentry: 
 243              self._update(args,dict) 
 244   
 245   
 246 -    def getfields(self): 
 247          return self.__fields 
 248   
 249   
 250 -    def _update(self, args, kwargs): 
 251          super(indexentry,self)._update(args,kwargs) 
 252          keys=kwargs.keys() 
 253          for key in keys: 
 254              if key in self.__fields: 
 255                  setattr(self, key, kwargs[key]) 
 256                  del kwargs[key] 
 257          # Were any unrecognized kwargs passed in? 
 258          if __debug__: 
 259              self._complainaboutunusedargs(indexentry,kwargs) 
 260          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 261          # Make all P fields that haven't already been constructed 
 262   
 263   
 264 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 265          'Writes this packet to the supplied buffer' 
 266          self._bufferstartoffset=buf.getcurrentoffset() 
 267          try: self.__field_index 
 268          except: 
 269              self.__field_index=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
 270          self.__field_index.writetobuffer(buf) 
 271          try: self.__field_name 
 272          except: 
 273              self.__field_name=USTRING(**{'sizeinbytes': 50, 'default': ""}) 
 274          self.__field_name.writetobuffer(buf) 
 275          self._bufferendoffset=buf.getcurrentoffset() 
 276          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 277   
 278   
 279 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 280          'Reads this packet from the supplied buffer' 
 281          self._bufferstartoffset=buf.getcurrentoffset() 
 282          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 283          self.__field_index=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
 284          self.__field_index.readfrombuffer(buf) 
 285          self.__field_name=USTRING(**{'sizeinbytes': 50, 'default': ""}) 
 286          self.__field_name.readfrombuffer(buf) 
 287          self._bufferendoffset=buf.getcurrentoffset() 
 288   
 289   
 290 -    def __getfield_index(self): 
 291          try: self.__field_index 
 292          except: 
 293              self.__field_index=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
 294          return self.__field_index.getvalue() 
 295   
 296 -    def __setfield_index(self, value): 
 297          if isinstance(value,UINT): 
 298              self.__field_index=value 
 299          else: 
 300              self.__field_index=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff}) 
 301   
 302 -    def __delfield_index(self): del self.__field_index 
 303   
 304      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
 305   
 306 -    def __getfield_name(self): 
 307          try: self.__field_name 
 308          except: 
 309              self.__field_name=USTRING(**{'sizeinbytes': 50, 'default': ""}) 
 310          return self.__field_name.getvalue() 
 311   
 312 -    def __setfield_name(self, value): 
 313          if isinstance(value,USTRING): 
 314              self.__field_name=value 
 315          else: 
 316              self.__field_name=USTRING(value,**{'sizeinbytes': 50, 'default': ""}) 
 317   
 318 -    def __delfield_name(self): del self.__field_name 
 319   
 320      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
 321   
 322 -    def iscontainer(self): 
 323          return True 
 324   
 325 -    def containerelements(self): 
 326          yield ('index', self.__field_index, None) 
 327          yield ('name', self.__field_name, None) 
 328   
 329   
 330   
 331   
 332 -class indexfile(BaseProtogenClass): 
 333      "Used for tracking wallpaper and ringtones" 
 334      __fields=['numactiveitems', 'items'] 
 335   
 336 -    def __init__(self, *args, **kwargs): 
 337          dict={} 
 338          # What was supplied to this function 
 339          dict.update(kwargs) 
 340          # Parent constructor 
 341          super(indexfile,self).__init__(**dict) 
 342          if self.__class__ is indexfile: 
 343              self._update(args,dict) 
 344   
 345   
 346 -    def getfields(self): 
 347          return self.__fields 
 348   
 349   
 350 -    def _update(self, args, kwargs): 
 351          super(indexfile,self)._update(args,kwargs) 
 352          keys=kwargs.keys() 
 353          for key in keys: 
 354              if key in self.__fields: 
 355                  setattr(self, key, kwargs[key]) 
 356                  del kwargs[key] 
 357          # Were any unrecognized kwargs passed in? 
 358          if __debug__: 
 359              self._complainaboutunusedargs(indexfile,kwargs) 
 360          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 361          # Make all P fields that haven't already been constructed 
 362   
 363   
 364 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 365          'Writes this packet to the supplied buffer' 
 366          self._bufferstartoffset=buf.getcurrentoffset() 
 367          self.__field_numactiveitems.writetobuffer(buf) 
 368          try: self.__field_items 
 369          except: 
 370              self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True}) 
 371          self.__field_items.writetobuffer(buf) 
 372          self._bufferendoffset=buf.getcurrentoffset() 
 373          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 374   
 375   
 376 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 377          'Reads this packet from the supplied buffer' 
 378          self._bufferstartoffset=buf.getcurrentoffset() 
 379          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 380          self.__field_numactiveitems=UINT(**{'sizeinbytes': 2}) 
 381          self.__field_numactiveitems.readfrombuffer(buf) 
 382          self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True}) 
 383          self.__field_items.readfrombuffer(buf) 
 384          self._bufferendoffset=buf.getcurrentoffset() 
 385   
 386   
 387 -    def __getfield_numactiveitems(self): 
 388          return self.__field_numactiveitems.getvalue() 
 389   
 390 -    def __setfield_numactiveitems(self, value): 
 391          if isinstance(value,UINT): 
 392              self.__field_numactiveitems=value 
 393          else: 
 394              self.__field_numactiveitems=UINT(value,**{'sizeinbytes': 2}) 
 395   
 396 -    def __delfield_numactiveitems(self): del self.__field_numactiveitems 
 397   
 398      numactiveitems=property(__getfield_numactiveitems, __setfield_numactiveitems, __delfield_numactiveitems, None) 
 399   
 400 -    def __getfield_items(self): 
 401          try: self.__field_items 
 402          except: 
 403              self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True}) 
 404          return self.__field_items.getvalue() 
 405   
 406 -    def __setfield_items(self, value): 
 407          if isinstance(value,LIST): 
 408              self.__field_items=value 
 409          else: 
 410              self.__field_items=LIST(value,**{'elementclass': indexentry, 'createdefault': True}) 
 411   
 412 -    def __delfield_items(self): del self.__field_items 
 413   
 414      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
 415   
 416 -    def iscontainer(self): 
 417          return True 
 418   
 419 -    def containerelements(self): 
 420          yield ('numactiveitems', self.__field_numactiveitems, None) 
 421          yield ('items', self.__field_items, None) 
 422   
 423   
 424   
 425   
 426 -class camindexentry(BaseProtogenClass): 
 427      __fields=['index', 'name', 'taken', 'dunno'] 
 428   
 429 -    def __init__(self, *args, **kwargs): 
 430          dict={} 
 431          # What was supplied to this function 
 432          dict.update(kwargs) 
 433          # Parent constructor 
 434          super(camindexentry,self).__init__(**dict) 
 435          if self.__class__ is camindexentry: 
 436              self._update(args,dict) 
 437   
 438   
 439 -    def getfields(self): 
 440          return self.__fields 
 441   
 442   
 443 -    def _update(self, args, kwargs): 
 444          super(camindexentry,self)._update(args,kwargs) 
 445          keys=kwargs.keys() 
 446          for key in keys: 
 447              if key in self.__fields: 
 448                  setattr(self, key, kwargs[key]) 
 449                  del kwargs[key] 
 450          # Were any unrecognized kwargs passed in? 
 451          if __debug__: 
 452              self._complainaboutunusedargs(camindexentry,kwargs) 
 453          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 454          # Make all P fields that haven't already been constructed 
 455   
 456   
 457 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 458          'Writes this packet to the supplied buffer' 
 459          self._bufferstartoffset=buf.getcurrentoffset() 
 460          try: self.__field_index 
 461          except: 
 462              self.__field_index=UINT(**{'sizeinbytes': 1, 'default': 0}) 
 463          self.__field_index.writetobuffer(buf) 
 464          try: self.__field_name 
 465          except: 
 466              self.__field_name=USTRING(**{'sizeinbytes': 11, 'default': ""}) 
 467          self.__field_name.writetobuffer(buf) 
 468          try: self.__field_taken 
 469          except: 
 470              self.__field_taken=LGCALDATE(**{'sizeinbytes': 4}) 
 471          self.__field_taken.writetobuffer(buf) 
 472          try: self.__field_dunno 
 473          except: 
 474              self.__field_dunno=UINT(**{'sizeinbytes': 4, 'default': 0x00ff0100}) 
 475          self.__field_dunno.writetobuffer(buf) 
 476          self._bufferendoffset=buf.getcurrentoffset() 
 477          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 478   
 479   
 480 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 481          'Reads this packet from the supplied buffer' 
 482          self._bufferstartoffset=buf.getcurrentoffset() 
 483          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 484          self.__field_index=UINT(**{'sizeinbytes': 1, 'default': 0}) 
 485          self.__field_index.readfrombuffer(buf) 
 486          self.__field_name=USTRING(**{'sizeinbytes': 11, 'default': ""}) 
 487          self.__field_name.readfrombuffer(buf) 
 488          self.__field_taken=LGCALDATE(**{'sizeinbytes': 4}) 
 489          self.__field_taken.readfrombuffer(buf) 
 490          self.__field_dunno=UINT(**{'sizeinbytes': 4, 'default': 0x00ff0100}) 
 491          self.__field_dunno.readfrombuffer(buf) 
 492          self._bufferendoffset=buf.getcurrentoffset() 
 493   
 494   
 495 -    def __getfield_index(self): 
 496          try: self.__field_index 
 497          except: 
 498              self.__field_index=UINT(**{'sizeinbytes': 1, 'default': 0}) 
 499          return self.__field_index.getvalue() 
 500   
 501 -    def __setfield_index(self, value): 
 502          if isinstance(value,UINT): 
 503              self.__field_index=value 
 504          else: 
 505              self.__field_index=UINT(value,**{'sizeinbytes': 1, 'default': 0}) 
 506   
 507 -    def __delfield_index(self): del self.__field_index 
 508   
 509      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
 510   
 511 -    def __getfield_name(self): 
 512          try: self.__field_name 
 513          except: 
 514              self.__field_name=USTRING(**{'sizeinbytes': 11, 'default': ""}) 
 515          return self.__field_name.getvalue() 
 516   
 517 -    def __setfield_name(self, value): 
 518          if isinstance(value,USTRING): 
 519              self.__field_name=value 
 520          else: 
 521              self.__field_name=USTRING(value,**{'sizeinbytes': 11, 'default': ""}) 
 522   
 523 -    def __delfield_name(self): del self.__field_name 
 524   
 525      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
 526   
 527 -    def __getfield_taken(self): 
 528          try: self.__field_taken 
 529          except: 
 530              self.__field_taken=LGCALDATE(**{'sizeinbytes': 4}) 
 531          return self.__field_taken.getvalue() 
 532   
 533 -    def __setfield_taken(self, value): 
 534          if isinstance(value,LGCALDATE): 
 535              self.__field_taken=value 
 536          else: 
 537              self.__field_taken=LGCALDATE(value,**{'sizeinbytes': 4}) 
 538   
 539 -    def __delfield_taken(self): del self.__field_taken 
 540   
 541      taken=property(__getfield_taken, __setfield_taken, __delfield_taken, None) 
 542   
 543 -    def __getfield_dunno(self): 
 544          try: self.__field_dunno 
 545          except: 
 546              self.__field_dunno=UINT(**{'sizeinbytes': 4, 'default': 0x00ff0100}) 
 547          return self.__field_dunno.getvalue() 
 548   
 549 -    def __setfield_dunno(self, value): 
 550          if isinstance(value,UINT): 
 551              self.__field_dunno=value 
 552          else: 
 553              self.__field_dunno=UINT(value,**{'sizeinbytes': 4, 'default': 0x00ff0100}) 
 554   
 555 -    def __delfield_dunno(self): del self.__field_dunno 
 556   
 557      dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, None) 
 558   
 559 -    def iscontainer(self): 
 560          return True 
 561   
 562 -    def containerelements(self): 
 563          yield ('index', self.__field_index, None) 
 564          yield ('name', self.__field_name, None) 
 565          yield ('taken', self.__field_taken, None) 
 566          yield ('dunno', self.__field_dunno, None) 
 567   
 568   
 569   
 570   
 571 -class campicsdat(BaseProtogenClass): 
 572      "the cam/pics.dat file" 
 573      __fields=['items'] 
 574   
 575 -    def __init__(self, *args, **kwargs): 
 576          dict={} 
 577          # What was supplied to this function 
 578          dict.update(kwargs) 
 579          # Parent constructor 
 580          super(campicsdat,self).__init__(**dict) 
 581          if self.__class__ is campicsdat: 
 582              self._update(args,dict) 
 583   
 584   
 585 -    def getfields(self): 
 586          return self.__fields 
 587   
 588   
 589 -    def _update(self, args, kwargs): 
 590          super(campicsdat,self)._update(args,kwargs) 
 591          keys=kwargs.keys() 
 592          for key in keys: 
 593              if key in self.__fields: 
 594                  setattr(self, key, kwargs[key]) 
 595                  del kwargs[key] 
 596          # Were any unrecognized kwargs passed in? 
 597          if __debug__: 
 598              self._complainaboutunusedargs(campicsdat,kwargs) 
 599          if len(args): 
 600              dict2={'length': 20, 'elementclass': camindexentry, 'createdefault': True} 
 601              dict2.update(kwargs) 
 602              kwargs=dict2 
 603              self.__field_items=LIST(*args,**dict2) 
 604          # Make all P fields that haven't already been constructed 
 605   
 606   
 607 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 608          'Writes this packet to the supplied buffer' 
 609          self._bufferstartoffset=buf.getcurrentoffset() 
 610          try: self.__field_items 
 611          except: 
 612              self.__field_items=LIST(**{'length': 20, 'elementclass': camindexentry, 'createdefault': True}) 
 613          self.__field_items.writetobuffer(buf) 
 614          self._bufferendoffset=buf.getcurrentoffset() 
 615          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 616   
 617   
 618 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 619          'Reads this packet from the supplied buffer' 
 620          self._bufferstartoffset=buf.getcurrentoffset() 
 621          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 622          self.__field_items=LIST(**{'length': 20, 'elementclass': camindexentry, 'createdefault': True}) 
 623          self.__field_items.readfrombuffer(buf) 
 624          self._bufferendoffset=buf.getcurrentoffset() 
 625   
 626   
 627 -    def __getfield_items(self): 
 628          try: self.__field_items 
 629          except: 
 630              self.__field_items=LIST(**{'length': 20, 'elementclass': camindexentry, 'createdefault': True}) 
 631          return self.__field_items.getvalue() 
 632   
 633 -    def __setfield_items(self, value): 
 634          if isinstance(value,LIST): 
 635              self.__field_items=value 
 636          else: 
 637              self.__field_items=LIST(value,**{'length': 20, 'elementclass': camindexentry, 'createdefault': True}) 
 638   
 639 -    def __delfield_items(self): del self.__field_items 
 640   
 641      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
 642   
 643 -    def iscontainer(self): 
 644          return True 
 645   
 646 -    def containerelements(self): 
 647          yield ('items', self.__field_items, None) 
 648   
 649   
 650   
 651   
 652 -class scheduleexception(BaseProtogenClass): 
 653      __fields=['pos', 'day', 'month', 'year'] 
 654   
 655 -    def __init__(self, *args, **kwargs): 
 656          dict={} 
 657          # What was supplied to this function 
 658          dict.update(kwargs) 
 659          # Parent constructor 
 660          super(scheduleexception,self).__init__(**dict) 
 661          if self.__class__ is scheduleexception: 
 662              self._update(args,dict) 
 663   
 664   
 665 -    def getfields(self): 
 666          return self.__fields 
 667   
 668   
 669 -    def _update(self, args, kwargs): 
 670          super(scheduleexception,self)._update(args,kwargs) 
 671          keys=kwargs.keys() 
 672          for key in keys: 
 673              if key in self.__fields: 
 674                  setattr(self, key, kwargs[key]) 
 675                  del kwargs[key] 
 676          # Were any unrecognized kwargs passed in? 
 677          if __debug__: 
 678              self._complainaboutunusedargs(scheduleexception,kwargs) 
 679          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 680          # Make all P fields that haven't already been constructed 
 681   
 682   
 683 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 684          'Writes this packet to the supplied buffer' 
 685          self._bufferstartoffset=buf.getcurrentoffset() 
 686          self.__field_pos.writetobuffer(buf) 
 687          self.__field_day.writetobuffer(buf) 
 688          self.__field_month.writetobuffer(buf) 
 689          self.__field_year.writetobuffer(buf) 
 690          self._bufferendoffset=buf.getcurrentoffset() 
 691          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 692   
 693   
 694 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 695          'Reads this packet from the supplied buffer' 
 696          self._bufferstartoffset=buf.getcurrentoffset() 
 697          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 698          self.__field_pos=UINT(**{'sizeinbytes': 4}) 
 699          self.__field_pos.readfrombuffer(buf) 
 700          self.__field_day=UINT(**{'sizeinbytes': 1}) 
 701          self.__field_day.readfrombuffer(buf) 
 702          self.__field_month=UINT(**{'sizeinbytes': 1}) 
 703          self.__field_month.readfrombuffer(buf) 
 704          self.__field_year=UINT(**{'sizeinbytes': 2}) 
 705          self.__field_year.readfrombuffer(buf) 
 706          self._bufferendoffset=buf.getcurrentoffset() 
 707   
 708   
 709 -    def __getfield_pos(self): 
 710          return self.__field_pos.getvalue() 
 711   
 712 -    def __setfield_pos(self, value): 
 713          if isinstance(value,UINT): 
 714              self.__field_pos=value 
 715          else: 
 716              self.__field_pos=UINT(value,**{'sizeinbytes': 4}) 
 717   
 718 -    def __delfield_pos(self): del self.__field_pos 
 719   
 720      pos=property(__getfield_pos, __setfield_pos, __delfield_pos, "Refers to event id (position in schedule file) that this suppresses") 
 721   
 722 -    def __getfield_day(self): 
 723          return self.__field_day.getvalue() 
 724   
 725 -    def __setfield_day(self, value): 
 726          if isinstance(value,UINT): 
 727              self.__field_day=value 
 728          else: 
 729              self.__field_day=UINT(value,**{'sizeinbytes': 1}) 
 730   
 731 -    def __delfield_day(self): del self.__field_day 
 732   
 733      day=property(__getfield_day, __setfield_day, __delfield_day, None) 
 734   
 735 -    def __getfield_month(self): 
 736          return self.__field_month.getvalue() 
 737   
 738 -    def __setfield_month(self, value): 
 739          if isinstance(value,UINT): 
 740              self.__field_month=value 
 741          else: 
 742              self.__field_month=UINT(value,**{'sizeinbytes': 1}) 
 743   
 744 -    def __delfield_month(self): del self.__field_month 
 745   
 746      month=property(__getfield_month, __setfield_month, __delfield_month, None) 
 747   
 748 -    def __getfield_year(self): 
 749          return self.__field_year.getvalue() 
 750   
 751 -    def __setfield_year(self, value): 
 752          if isinstance(value,UINT): 
 753              self.__field_year=value 
 754          else: 
 755              self.__field_year=UINT(value,**{'sizeinbytes': 2}) 
 756   
 757 -    def __delfield_year(self): del self.__field_year 
 758   
 759      year=property(__getfield_year, __setfield_year, __delfield_year, None) 
 760   
 761 -    def iscontainer(self): 
 762          return True 
 763   
 764 -    def containerelements(self): 
 765          yield ('pos', self.__field_pos, "Refers to event id (position in schedule file) that this suppresses") 
 766          yield ('day', self.__field_day, None) 
 767          yield ('month', self.__field_month, None) 
 768          yield ('year', self.__field_year, None) 
 769   
 770   
 771   
 772   
 773 -class scheduleexceptionfile(BaseProtogenClass): 
 774      __fields=['items'] 
 775   
 776 -    def __init__(self, *args, **kwargs): 
 777          dict={} 
 778          # What was supplied to this function 
 779          dict.update(kwargs) 
 780          # Parent constructor 
 781          super(scheduleexceptionfile,self).__init__(**dict) 
 782          if self.__class__ is scheduleexceptionfile: 
 783              self._update(args,dict) 
 784   
 785   
 786 -    def getfields(self): 
 787          return self.__fields 
 788   
 789   
 790 -    def _update(self, args, kwargs): 
 791          super(scheduleexceptionfile,self)._update(args,kwargs) 
 792          keys=kwargs.keys() 
 793          for key in keys: 
 794              if key in self.__fields: 
 795                  setattr(self, key, kwargs[key]) 
 796                  del kwargs[key] 
 797          # Were any unrecognized kwargs passed in? 
 798          if __debug__: 
 799              self._complainaboutunusedargs(scheduleexceptionfile,kwargs) 
 800          if len(args): 
 801              dict2={'elementclass': scheduleexception} 
 802              dict2.update(kwargs) 
 803              kwargs=dict2 
 804              self.__field_items=LIST(*args,**dict2) 
 805          # Make all P fields that haven't already been constructed 
 806   
 807   
 808 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 809          'Writes this packet to the supplied buffer' 
 810          self._bufferstartoffset=buf.getcurrentoffset() 
 811          try: self.__field_items 
 812          except: 
 813              self.__field_items=LIST(**{'elementclass': scheduleexception}) 
 814          self.__field_items.writetobuffer(buf) 
 815          self._bufferendoffset=buf.getcurrentoffset() 
 816          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 817   
 818   
 819 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 820          'Reads this packet from the supplied buffer' 
 821          self._bufferstartoffset=buf.getcurrentoffset() 
 822          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 823          self.__field_items=LIST(**{'elementclass': scheduleexception}) 
 824          self.__field_items.readfrombuffer(buf) 
 825          self._bufferendoffset=buf.getcurrentoffset() 
 826   
 827   
 828 -    def __getfield_items(self): 
 829          try: self.__field_items 
 830          except: 
 831              self.__field_items=LIST(**{'elementclass': scheduleexception}) 
 832          return self.__field_items.getvalue() 
 833   
 834 -    def __setfield_items(self, value): 
 835          if isinstance(value,LIST): 
 836              self.__field_items=value 
 837          else: 
 838              self.__field_items=LIST(value,**{'elementclass': scheduleexception}) 
 839   
 840 -    def __delfield_items(self): del self.__field_items 
 841   
 842      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
 843   
 844 -    def iscontainer(self): 
 845          return True 
 846   
 847 -    def containerelements(self): 
 848          yield ('items', self.__field_items, None) 
 849   
 850   
 851   
 852   
 853 -class scheduleevent(BaseProtogenClass): 
 854      __fields=['packet_size', 'pos', 'start', 'end', 'repeat', 'daybitmap', 'pad2', 'alarmminutes', 'alarmhours', 'alarmtype', 'snoozedelay', 'ringtone', 'description'] 
 855   
 856 -    def __init__(self, *args, **kwargs): 
 857          dict={} 
 858          # What was supplied to this function 
 859          dict.update(kwargs) 
 860          # Parent constructor 
 861          super(scheduleevent,self).__init__(**dict) 
 862          if self.__class__ is scheduleevent: 
 863              self._update(args,dict) 
 864   
 865   
 866 -    def getfields(self): 
 867          return self.__fields 
 868   
 869   
 870 -    def _update(self, args, kwargs): 
 871          super(scheduleevent,self)._update(args,kwargs) 
 872          keys=kwargs.keys() 
 873          for key in keys: 
 874              if key in self.__fields: 
 875                  setattr(self, key, kwargs[key]) 
 876                  del kwargs[key] 
 877          # Were any unrecognized kwargs passed in? 
 878          if __debug__: 
 879              self._complainaboutunusedargs(scheduleevent,kwargs) 
 880          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 881          # Make all P fields that haven't already been constructed 
 882          try: self.__field_packet_size 
 883          except: 
 884              self.__field_packet_size=UINT(**{ 'constant': 60 }) 
 885   
 886   
 887 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 888          'Writes this packet to the supplied buffer' 
 889          self._bufferstartoffset=buf.getcurrentoffset() 
 890          self.__field_pos.writetobuffer(buf) 
 891          self.__field_start.writetobuffer(buf) 
 892          self.__field_end.writetobuffer(buf) 
 893          self.__field_repeat.writetobuffer(buf) 
 894          self.__field_daybitmap.writetobuffer(buf) 
 895          try: self.__field_pad2 
 896          except: 
 897              self.__field_pad2=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
 898          self.__field_pad2.writetobuffer(buf) 
 899          self.__field_alarmminutes.writetobuffer(buf) 
 900          self.__field_alarmhours.writetobuffer(buf) 
 901          self.__field_alarmtype.writetobuffer(buf) 
 902          try: self.__field_snoozedelay 
 903          except: 
 904              self.__field_snoozedelay=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
 905          self.__field_snoozedelay.writetobuffer(buf) 
 906          self.__field_ringtone.writetobuffer(buf) 
 907          self.__field_description.writetobuffer(buf) 
 908          self._bufferendoffset=buf.getcurrentoffset() 
 909          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 910   
 911   
 912 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 913          'Reads this packet from the supplied buffer' 
 914          self._bufferstartoffset=buf.getcurrentoffset() 
 915          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 916          self.__field_pos=UINT(**{'sizeinbytes': 4}) 
 917          self.__field_pos.readfrombuffer(buf) 
 918          self.__field_start=LGCALDATE(**{'sizeinbytes': 4}) 
 919          self.__field_start.readfrombuffer(buf) 
 920          self.__field_end=LGCALDATE(**{'sizeinbytes': 4}) 
 921          self.__field_end.readfrombuffer(buf) 
 922          self.__field_repeat=UINT(**{'sizeinbytes': 1}) 
 923          self.__field_repeat.readfrombuffer(buf) 
 924          self.__field_daybitmap=UINT(**{'sizeinbytes': 2}) 
 925          self.__field_daybitmap.readfrombuffer(buf) 
 926          self.__field_pad2=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
 927          self.__field_pad2.readfrombuffer(buf) 
 928          self.__field_alarmminutes=UINT(**{'sizeinbytes': 1}) 
 929          self.__field_alarmminutes.readfrombuffer(buf) 
 930          self.__field_alarmhours=UINT(**{'sizeinbytes': 1}) 
 931          self.__field_alarmhours.readfrombuffer(buf) 
 932          self.__field_alarmtype=UINT(**{'sizeinbytes': 1}) 
 933          self.__field_alarmtype.readfrombuffer(buf) 
 934          self.__field_snoozedelay=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
 935          self.__field_snoozedelay.readfrombuffer(buf) 
 936          self.__field_ringtone=UINT(**{'sizeinbytes': 1}) 
 937          self.__field_ringtone.readfrombuffer(buf) 
 938          self.__field_description=USTRING(**{'sizeinbytes': 39, 'raiseontruncate': False,               'raiseonunterminatedread': False }) 
 939          self.__field_description.readfrombuffer(buf) 
 940          self._bufferendoffset=buf.getcurrentoffset() 
 941   
 942   
 943 -    def __getfield_packet_size(self): 
 944          return self.__field_packet_size.getvalue() 
 945   
 946 -    def __setfield_packet_size(self, value): 
 947          if isinstance(value,UINT): 
 948              self.__field_packet_size=value 
 949          else: 
 950              self.__field_packet_size=UINT(value,**{ 'constant': 60 }) 
 951   
 952 -    def __delfield_packet_size(self): del self.__field_packet_size 
 953   
 954      packet_size=property(__getfield_packet_size, __setfield_packet_size, __delfield_packet_size, "Faster than packetsize()") 
 955   
 956 -    def __getfield_pos(self): 
 957          return self.__field_pos.getvalue() 
 958   
 959 -    def __setfield_pos(self, value): 
 960          if isinstance(value,UINT): 
 961              self.__field_pos=value 
 962          else: 
 963              self.__field_pos=UINT(value,**{'sizeinbytes': 4}) 
 964   
 965 -    def __delfield_pos(self): del self.__field_pos 
 966   
 967      pos=property(__getfield_pos, __setfield_pos, __delfield_pos, "position within file, used as an event id") 
 968   
 969 -    def __getfield_start(self): 
 970          return self.__field_start.getvalue() 
 971   
 972 -    def __setfield_start(self, value): 
 973          if isinstance(value,LGCALDATE): 
 974              self.__field_start=value 
 975          else: 
 976              self.__field_start=LGCALDATE(value,**{'sizeinbytes': 4}) 
 977   
 978 -    def __delfield_start(self): del self.__field_start 
 979   
 980      start=property(__getfield_start, __setfield_start, __delfield_start, None) 
 981   
 982 -    def __getfield_end(self): 
 983          return self.__field_end.getvalue() 
 984   
 985 -    def __setfield_end(self, value): 
 986          if isinstance(value,LGCALDATE): 
 987              self.__field_end=value 
 988          else: 
 989              self.__field_end=LGCALDATE(value,**{'sizeinbytes': 4}) 
 990   
 991 -    def __delfield_end(self): del self.__field_end 
 992   
 993      end=property(__getfield_end, __setfield_end, __delfield_end, None) 
 994   
 995 -    def __getfield_repeat(self): 
 996          return self.__field_repeat.getvalue() 
 997   
 998 -    def __setfield_repeat(self, value): 
 999          if isinstance(value,UINT): 
1000              self.__field_repeat=value 
1001          else: 
1002              self.__field_repeat=UINT(value,**{'sizeinbytes': 1}) 
1003   
1004 -    def __delfield_repeat(self): del self.__field_repeat 
1005   
1006      repeat=property(__getfield_repeat, __setfield_repeat, __delfield_repeat, None) 
1007   
1008 -    def __getfield_daybitmap(self): 
1009          return self.__field_daybitmap.getvalue() 
1010   
1011 -    def __setfield_daybitmap(self, value): 
1012          if isinstance(value,UINT): 
1013              self.__field_daybitmap=value 
1014          else: 
1015              self.__field_daybitmap=UINT(value,**{'sizeinbytes': 2}) 
1016   
1017 -    def __delfield_daybitmap(self): del self.__field_daybitmap 
1018   
1019      daybitmap=property(__getfield_daybitmap, __setfield_daybitmap, __delfield_daybitmap, "which days a weekly repeat event happens on") 
1020   
1021 -    def __getfield_pad2(self): 
1022          try: self.__field_pad2 
1023          except: 
1024              self.__field_pad2=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
1025          return self.__field_pad2.getvalue() 
1026   
1027 -    def __setfield_pad2(self, value): 
1028          if isinstance(value,UINT): 
1029              self.__field_pad2=value 
1030          else: 
1031              self.__field_pad2=UINT(value,**{'sizeinbytes': 1,  'default': 0 }) 
1032   
1033 -    def __delfield_pad2(self): del self.__field_pad2 
1034   
1035      pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None) 
1036   
1037 -    def __getfield_alarmminutes(self): 
1038          return self.__field_alarmminutes.getvalue() 
1039   
1040 -    def __setfield_alarmminutes(self, value): 
1041          if isinstance(value,UINT): 
1042              self.__field_alarmminutes=value 
1043          else: 
1044              self.__field_alarmminutes=UINT(value,**{'sizeinbytes': 1}) 
1045   
1046 -    def __delfield_alarmminutes(self): del self.__field_alarmminutes 
1047   
1048      alarmminutes=property(__getfield_alarmminutes, __setfield_alarmminutes, __delfield_alarmminutes, "a value of 100 indicates not set") 
1049   
1050 -    def __getfield_alarmhours(self): 
1051          return self.__field_alarmhours.getvalue() 
1052   
1053 -    def __setfield_alarmhours(self, value): 
1054          if isinstance(value,UINT): 
1055              self.__field_alarmhours=value 
1056          else: 
1057              self.__field_alarmhours=UINT(value,**{'sizeinbytes': 1}) 
1058   
1059 -    def __delfield_alarmhours(self): del self.__field_alarmhours 
1060   
1061      alarmhours=property(__getfield_alarmhours, __setfield_alarmhours, __delfield_alarmhours, "a value of 100 indicates not set") 
1062   
1063 -    def __getfield_alarmtype(self): 
1064          return self.__field_alarmtype.getvalue() 
1065   
1066 -    def __setfield_alarmtype(self, value): 
1067          if isinstance(value,UINT): 
1068              self.__field_alarmtype=value 
1069          else: 
1070              self.__field_alarmtype=UINT(value,**{'sizeinbytes': 1}) 
1071   
1072 -    def __delfield_alarmtype(self): del self.__field_alarmtype 
1073   
1074      alarmtype=property(__getfield_alarmtype, __setfield_alarmtype, __delfield_alarmtype, "preset alarm reminder type") 
1075   
1076 -    def __getfield_snoozedelay(self): 
1077          try: self.__field_snoozedelay 
1078          except: 
1079              self.__field_snoozedelay=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
1080          return self.__field_snoozedelay.getvalue() 
1081   
1082 -    def __setfield_snoozedelay(self, value): 
1083          if isinstance(value,UINT): 
1084              self.__field_snoozedelay=value 
1085          else: 
1086              self.__field_snoozedelay=UINT(value,**{'sizeinbytes': 1,  'default': 0 }) 
1087   
1088 -    def __delfield_snoozedelay(self): del self.__field_snoozedelay 
1089   
1090      snoozedelay=property(__getfield_snoozedelay, __setfield_snoozedelay, __delfield_snoozedelay, "in minutes, not for this phone") 
1091   
1092 -    def __getfield_ringtone(self): 
1093          return self.__field_ringtone.getvalue() 
1094   
1095 -    def __setfield_ringtone(self, value): 
1096          if isinstance(value,UINT): 
1097              self.__field_ringtone=value 
1098          else: 
1099              self.__field_ringtone=UINT(value,**{'sizeinbytes': 1}) 
1100   
1101 -    def __delfield_ringtone(self): del self.__field_ringtone 
1102   
1103      ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 
1104   
1105 -    def __getfield_description(self): 
1106          return self.__field_description.getvalue() 
1107   
1108 -    def __setfield_description(self, value): 
1109          if isinstance(value,USTRING): 
1110              self.__field_description=value 
1111          else: 
1112              self.__field_description=USTRING(value,**{'sizeinbytes': 39, 'raiseontruncate': False,               'raiseonunterminatedread': False }) 
1113   
1114 -    def __delfield_description(self): del self.__field_description 
1115   
1116      description=property(__getfield_description, __setfield_description, __delfield_description, None) 
1117   
1118 -    def iscontainer(self): 
1119          return True 
1120   
1121 -    def containerelements(self): 
1122          yield ('packet_size', self.__field_packet_size, "Faster than packetsize()") 
1123          yield ('pos', self.__field_pos, "position within file, used as an event id") 
1124          yield ('start', self.__field_start, None) 
1125          yield ('end', self.__field_end, None) 
1126          yield ('repeat', self.__field_repeat, None) 
1127          yield ('daybitmap', self.__field_daybitmap, "which days a weekly repeat event happens on") 
1128          yield ('pad2', self.__field_pad2, None) 
1129          yield ('alarmminutes', self.__field_alarmminutes, "a value of 100 indicates not set") 
1130          yield ('alarmhours', self.__field_alarmhours, "a value of 100 indicates not set") 
1131          yield ('alarmtype', self.__field_alarmtype, "preset alarm reminder type") 
1132          yield ('snoozedelay', self.__field_snoozedelay, "in minutes, not for this phone") 
1133          yield ('ringtone', self.__field_ringtone, None) 
1134          yield ('description', self.__field_description, None) 
1135   
1136   
1137   
1138   
1139 -class schedulefile(BaseProtogenClass): 
1140      __fields=['numactiveitems', 'events'] 
1141   
1142 -    def __init__(self, *args, **kwargs): 
1143          dict={} 
1144          # What was supplied to this function 
1145          dict.update(kwargs) 
1146          # Parent constructor 
1147          super(schedulefile,self).__init__(**dict) 
1148          if self.__class__ is schedulefile: 
1149              self._update(args,dict) 
1150   
1151   
1152 -    def getfields(self): 
1153          return self.__fields 
1154   
1155   
1156 -    def _update(self, args, kwargs): 
1157          super(schedulefile,self)._update(args,kwargs) 
1158          keys=kwargs.keys() 
1159          for key in keys: 
1160              if key in self.__fields: 
1161                  setattr(self, key, kwargs[key]) 
1162                  del kwargs[key] 
1163          # Were any unrecognized kwargs passed in? 
1164          if __debug__: 
1165              self._complainaboutunusedargs(schedulefile,kwargs) 
1166          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1167          # Make all P fields that haven't already been constructed 
1168   
1169   
1170 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1171          'Writes this packet to the supplied buffer' 
1172          self._bufferstartoffset=buf.getcurrentoffset() 
1173          self.__field_numactiveitems.writetobuffer(buf) 
1174          try: self.__field_events 
1175          except: 
1176              self.__field_events=LIST(**{'elementclass': scheduleevent}) 
1177          self.__field_events.writetobuffer(buf) 
1178          self._bufferendoffset=buf.getcurrentoffset() 
1179          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1180   
1181   
1182 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1183          'Reads this packet from the supplied buffer' 
1184          self._bufferstartoffset=buf.getcurrentoffset() 
1185          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1186          self.__field_numactiveitems=UINT(**{'sizeinbytes': 2}) 
1187          self.__field_numactiveitems.readfrombuffer(buf) 
1188          self.__field_events=LIST(**{'elementclass': scheduleevent}) 
1189          self.__field_events.readfrombuffer(buf) 
1190          self._bufferendoffset=buf.getcurrentoffset() 
1191   
1192   
1193 -    def __getfield_numactiveitems(self): 
1194          return self.__field_numactiveitems.getvalue() 
1195   
1196 -    def __setfield_numactiveitems(self, value): 
1197          if isinstance(value,UINT): 
1198              self.__field_numactiveitems=value 
1199          else: 
1200              self.__field_numactiveitems=UINT(value,**{'sizeinbytes': 2}) 
1201   
1202 -    def __delfield_numactiveitems(self): del self.__field_numactiveitems 
1203   
1204      numactiveitems=property(__getfield_numactiveitems, __setfield_numactiveitems, __delfield_numactiveitems, None) 
1205   
1206 -    def __getfield_events(self): 
1207          try: self.__field_events 
1208          except: 
1209              self.__field_events=LIST(**{'elementclass': scheduleevent}) 
1210          return self.__field_events.getvalue() 
1211   
1212 -    def __setfield_events(self, value): 
1213          if isinstance(value,LIST): 
1214              self.__field_events=value 
1215          else: 
1216              self.__field_events=LIST(value,**{'elementclass': scheduleevent}) 
1217   
1218 -    def __delfield_events(self): del self.__field_events 
1219   
1220      events=property(__getfield_events, __setfield_events, __delfield_events, None) 
1221   
1222 -    def iscontainer(self): 
1223          return True 
1224   
1225 -    def containerelements(self): 
1226          yield ('numactiveitems', self.__field_numactiveitems, None) 
1227          yield ('events', self.__field_events, None) 
1228   
1229   
1230   
1231   
1232 -class call(BaseProtogenClass): 
1233      __fields=['GPStime', 'unknown1', 'duration', 'number', 'name', 'numberlength', 'unknown2', 'pbnumbertype', 'unknown3', 'pbentrynum'] 
1234   
1235 -    def __init__(self, *args, **kwargs): 
1236          dict={} 
1237          # What was supplied to this function 
1238          dict.update(kwargs) 
1239          # Parent constructor 
1240          super(call,self).__init__(**dict) 
1241          if self.__class__ is call: 
1242              self._update(args,dict) 
1243   
1244   
1245 -    def getfields(self): 
1246          return self.__fields 
1247   
1248   
1249 -    def _update(self, args, kwargs): 
1250          super(call,self)._update(args,kwargs) 
1251          keys=kwargs.keys() 
1252          for key in keys: 
1253              if key in self.__fields: 
1254                  setattr(self, key, kwargs[key]) 
1255                  del kwargs[key] 
1256          # Were any unrecognized kwargs passed in? 
1257          if __debug__: 
1258              self._complainaboutunusedargs(call,kwargs) 
1259          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1260          # Make all P fields that haven't already been constructed 
1261   
1262   
1263 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1264          'Writes this packet to the supplied buffer' 
1265          self._bufferstartoffset=buf.getcurrentoffset() 
1266          self.__field_GPStime.writetobuffer(buf) 
1267          self.__field_unknown1.writetobuffer(buf) 
1268          self.__field_duration.writetobuffer(buf) 
1269          self.__field_number.writetobuffer(buf) 
1270          self.__field_name.writetobuffer(buf) 
1271          self.__field_numberlength.writetobuffer(buf) 
1272          self.__field_unknown2.writetobuffer(buf) 
1273          self.__field_pbnumbertype.writetobuffer(buf) 
1274          self.__field_unknown3.writetobuffer(buf) 
1275          self.__field_pbentrynum.writetobuffer(buf) 
1276          self._bufferendoffset=buf.getcurrentoffset() 
1277          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1278   
1279   
1280 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1281          'Reads this packet from the supplied buffer' 
1282          self._bufferstartoffset=buf.getcurrentoffset() 
1283          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1284          self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4}) 
1285          self.__field_GPStime.readfrombuffer(buf) 
1286          self.__field_unknown1=UINT(**{'sizeinbytes': 4}) 
1287          self.__field_unknown1.readfrombuffer(buf) 
1288          self.__field_duration=UINT(**{'sizeinbytes': 4}) 
1289          self.__field_duration.readfrombuffer(buf) 
1290          self.__field_number=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 
1291          self.__field_number.readfrombuffer(buf) 
1292          self.__field_name=USTRING(**{'sizeinbytes': 36, 'raiseonunterminatedread': False}) 
1293          self.__field_name.readfrombuffer(buf) 
1294          self.__field_numberlength=UINT(**{'sizeinbytes': 1}) 
1295          self.__field_numberlength.readfrombuffer(buf) 
1296          self.__field_unknown2=UINT(**{'sizeinbytes': 1}) 
1297          self.__field_unknown2.readfrombuffer(buf) 
1298          self.__field_pbnumbertype=UINT(**{'sizeinbytes': 1}) 
1299          self.__field_pbnumbertype.readfrombuffer(buf) 
1300          self.__field_unknown3=UINT(**{'sizeinbytes': 2}) 
1301          self.__field_unknown3.readfrombuffer(buf) 
1302          self.__field_pbentrynum=UINT(**{'sizeinbytes': 2}) 
1303          self.__field_pbentrynum.readfrombuffer(buf) 
1304          self._bufferendoffset=buf.getcurrentoffset() 
1305   
1306   
1307 -    def __getfield_GPStime(self): 
1308          return self.__field_GPStime.getvalue() 
1309   
1310 -    def __setfield_GPStime(self, value): 
1311          if isinstance(value,GPSDATE): 
1312              self.__field_GPStime=value 
1313          else: 
1314              self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4}) 
1315   
1316 -    def __delfield_GPStime(self): del self.__field_GPStime 
1317   
1318      GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None) 
1319   
1320 -    def __getfield_unknown1(self): 
1321          return self.__field_unknown1.getvalue() 
1322   
1323 -    def __setfield_unknown1(self, value): 
1324          if isinstance(value,UINT): 
1325              self.__field_unknown1=value 
1326          else: 
1327              self.__field_unknown1=UINT(value,**{'sizeinbytes': 4}) 
1328   
1329 -    def __delfield_unknown1(self): del self.__field_unknown1 
1330   
1331      unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 
1332   
1333 -    def __getfield_duration(self): 
1334          return self.__field_duration.getvalue() 
1335   
1336 -    def __setfield_duration(self, value): 
1337          if isinstance(value,UINT): 
1338              self.__field_duration=value 
1339          else: 
1340              self.__field_duration=UINT(value,**{'sizeinbytes': 4}) 
1341   
1342 -    def __delfield_duration(self): del self.__field_duration 
1343   
1344      duration=property(__getfield_duration, __setfield_duration, __delfield_duration, None) 
1345   
1346 -    def __getfield_number(self): 
1347          return self.__field_number.getvalue() 
1348   
1349 -    def __setfield_number(self, value): 
1350          if isinstance(value,USTRING): 
1351              self.__field_number=value 
1352          else: 
1353              self.__field_number=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 
1354   
1355 -    def __delfield_number(self): del self.__field_number 
1356   
1357      number=property(__getfield_number, __setfield_number, __delfield_number, None) 
1358   
1359 -    def __getfield_name(self): 
1360          return self.__field_name.getvalue() 
1361   
1362 -    def __setfield_name(self, value): 
1363          if isinstance(value,USTRING): 
1364              self.__field_name=value 
1365          else: 
1366              self.__field_name=USTRING(value,**{'sizeinbytes': 36, 'raiseonunterminatedread': False}) 
1367   
1368 -    def __delfield_name(self): del self.__field_name 
1369   
1370      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
1371   
1372 -    def __getfield_numberlength(self): 
1373          return self.__field_numberlength.getvalue() 
1374   
1375 -    def __setfield_numberlength(self, value): 
1376          if isinstance(value,UINT): 
1377              self.__field_numberlength=value 
1378          else: 
1379              self.__field_numberlength=UINT(value,**{'sizeinbytes': 1}) 
1380   
1381 -    def __delfield_numberlength(self): del self.__field_numberlength 
1382   
1383      numberlength=property(__getfield_numberlength, __setfield_numberlength, __delfield_numberlength, None) 
1384   
1385 -    def __getfield_unknown2(self): 
1386          return self.__field_unknown2.getvalue() 
1387   
1388 -    def __setfield_unknown2(self, value): 
1389          if isinstance(value,UINT): 
1390              self.__field_unknown2=value 
1391          else: 
1392              self.__field_unknown2=UINT(value,**{'sizeinbytes': 1}) 
1393   
1394 -    def __delfield_unknown2(self): del self.__field_unknown2 
1395   
1396      unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None) 
1397   
1398 -    def __getfield_pbnumbertype(self): 
1399          return self.__field_pbnumbertype.getvalue() 
1400   
1401 -    def __setfield_pbnumbertype(self, value): 
1402          if isinstance(value,UINT): 
1403              self.__field_pbnumbertype=value 
1404          else: 
1405              self.__field_pbnumbertype=UINT(value,**{'sizeinbytes': 1}) 
1406   
1407 -    def __delfield_pbnumbertype(self): del self.__field_pbnumbertype 
1408   
1409      pbnumbertype=property(__getfield_pbnumbertype, __setfield_pbnumbertype, __delfield_pbnumbertype, None) 
1410   
1411 -    def __getfield_unknown3(self): 
1412          return self.__field_unknown3.getvalue() 
1413   
1414 -    def __setfield_unknown3(self, value): 
1415          if isinstance(value,UINT): 
1416              self.__field_unknown3=value 
1417          else: 
1418              self.__field_unknown3=UINT(value,**{'sizeinbytes': 2}) 
1419   
1420 -    def __delfield_unknown3(self): del self.__field_unknown3 
1421   
1422      unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None) 
1423   
1424 -    def __getfield_pbentrynum(self): 
1425          return self.__field_pbentrynum.getvalue() 
1426   
1427 -    def __setfield_pbentrynum(self, value): 
1428          if isinstance(value,UINT): 
1429              self.__field_pbentrynum=value 
1430          else: 
1431              self.__field_pbentrynum=UINT(value,**{'sizeinbytes': 2}) 
1432   
1433 -    def __delfield_pbentrynum(self): del self.__field_pbentrynum 
1434   
1435      pbentrynum=property(__getfield_pbentrynum, __setfield_pbentrynum, __delfield_pbentrynum, None) 
1436   
1437 -    def iscontainer(self): 
1438          return True 
1439   
1440 -    def containerelements(self): 
1441          yield ('GPStime', self.__field_GPStime, None) 
1442          yield ('unknown1', self.__field_unknown1, None) 
1443          yield ('duration', self.__field_duration, None) 
1444          yield ('number', self.__field_number, None) 
1445          yield ('name', self.__field_name, None) 
1446          yield ('numberlength', self.__field_numberlength, None) 
1447          yield ('unknown2', self.__field_unknown2, None) 
1448          yield ('pbnumbertype', self.__field_pbnumbertype, None) 
1449          yield ('unknown3', self.__field_unknown3, None) 
1450          yield ('pbentrynum', self.__field_pbentrynum, None) 
1451   
1452   
1453   
1454   
1455 -class callhistory(BaseProtogenClass): 
1456      __fields=['numcalls', 'unknown1', 'calls'] 
1457   
1458 -    def __init__(self, *args, **kwargs): 
1459          dict={} 
1460          # What was supplied to this function 
1461          dict.update(kwargs) 
1462          # Parent constructor 
1463          super(callhistory,self).__init__(**dict) 
1464          if self.__class__ is callhistory: 
1465              self._update(args,dict) 
1466   
1467   
1468 -    def getfields(self): 
1469          return self.__fields 
1470   
1471   
1472 -    def _update(self, args, kwargs): 
1473          super(callhistory,self)._update(args,kwargs) 
1474          keys=kwargs.keys() 
1475          for key in keys: 
1476              if key in self.__fields: 
1477                  setattr(self, key, kwargs[key]) 
1478                  del kwargs[key] 
1479          # Were any unrecognized kwargs passed in? 
1480          if __debug__: 
1481              self._complainaboutunusedargs(callhistory,kwargs) 
1482          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1483          # Make all P fields that haven't already been constructed 
1484   
1485   
1486 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1487          'Writes this packet to the supplied buffer' 
1488          self._bufferstartoffset=buf.getcurrentoffset() 
1489          self.__field_numcalls.writetobuffer(buf) 
1490          self.__field_unknown1.writetobuffer(buf) 
1491          try: self.__field_calls 
1492          except: 
1493              self.__field_calls=LIST(**{'elementclass': call}) 
1494          self.__field_calls.writetobuffer(buf) 
1495          self._bufferendoffset=buf.getcurrentoffset() 
1496          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1497   
1498   
1499 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1500          'Reads this packet from the supplied buffer' 
1501          self._bufferstartoffset=buf.getcurrentoffset() 
1502          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1503          self.__field_numcalls=UINT(**{'sizeinbytes': 4}) 
1504          self.__field_numcalls.readfrombuffer(buf) 
1505          self.__field_unknown1=UINT(**{'sizeinbytes': 1}) 
1506          self.__field_unknown1.readfrombuffer(buf) 
1507          self.__field_calls=LIST(**{'elementclass': call}) 
1508          self.__field_calls.readfrombuffer(buf) 
1509          self._bufferendoffset=buf.getcurrentoffset() 
1510   
1511   
1512 -    def __getfield_numcalls(self): 
1513          return self.__field_numcalls.getvalue() 
1514   
1515 -    def __setfield_numcalls(self, value): 
1516          if isinstance(value,UINT): 
1517              self.__field_numcalls=value 
1518          else: 
1519              self.__field_numcalls=UINT(value,**{'sizeinbytes': 4}) 
1520   
1521 -    def __delfield_numcalls(self): del self.__field_numcalls 
1522   
1523      numcalls=property(__getfield_numcalls, __setfield_numcalls, __delfield_numcalls, None) 
1524   
1525 -    def __getfield_unknown1(self): 
1526          return self.__field_unknown1.getvalue() 
1527   
1528 -    def __setfield_unknown1(self, value): 
1529          if isinstance(value,UINT): 
1530              self.__field_unknown1=value 
1531          else: 
1532              self.__field_unknown1=UINT(value,**{'sizeinbytes': 1}) 
1533   
1534 -    def __delfield_unknown1(self): del self.__field_unknown1 
1535   
1536      unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 
1537   
1538 -    def __getfield_calls(self): 
1539          try: self.__field_calls 
1540          except: 
1541              self.__field_calls=LIST(**{'elementclass': call}) 
1542          return self.__field_calls.getvalue() 
1543   
1544 -    def __setfield_calls(self, value): 
1545          if isinstance(value,LIST): 
1546              self.__field_calls=value 
1547          else: 
1548              self.__field_calls=LIST(value,**{'elementclass': call}) 
1549   
1550 -    def __delfield_calls(self): del self.__field_calls 
1551   
1552      calls=property(__getfield_calls, __setfield_calls, __delfield_calls, None) 
1553   
1554 -    def iscontainer(self): 
1555          return True 
1556   
1557 -    def containerelements(self): 
1558          yield ('numcalls', self.__field_numcalls, None) 
1559          yield ('unknown1', self.__field_unknown1, None) 
1560          yield ('calls', self.__field_calls, None) 
1561   
1562   
1563   
1564   
1565 -class msg_record(BaseProtogenClass): 
1566      __fields=['unknown1', 'binary', 'unknown3', 'unknown4', 'unknown6', 'length', 'msg'] 
1567   
1568 -    def __init__(self, *args, **kwargs): 
1569          dict={} 
1570          # What was supplied to this function 
1571          dict.update(kwargs) 
1572          # Parent constructor 
1573          super(msg_record,self).__init__(**dict) 
1574          if self.__class__ is msg_record: 
1575              self._update(args,dict) 
1576   
1577   
1578 -    def getfields(self): 
1579          return self.__fields 
1580   
1581   
1582 -    def _update(self, args, kwargs): 
1583          super(msg_record,self)._update(args,kwargs) 
1584          keys=kwargs.keys() 
1585          for key in keys: 
1586              if key in self.__fields: 
1587                  setattr(self, key, kwargs[key]) 
1588                  del kwargs[key] 
1589          # Were any unrecognized kwargs passed in? 
1590          if __debug__: 
1591              self._complainaboutunusedargs(msg_record,kwargs) 
1592          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1593          # Make all P fields that haven't already been constructed 
1594   
1595   
1596 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1597          'Writes this packet to the supplied buffer' 
1598          self._bufferstartoffset=buf.getcurrentoffset() 
1599          self.__field_unknown1.writetobuffer(buf) 
1600          self.__field_binary.writetobuffer(buf) 
1601          self.__field_unknown3.writetobuffer(buf) 
1602          self.__field_unknown4.writetobuffer(buf) 
1603          self.__field_unknown6.writetobuffer(buf) 
1604          self.__field_length.writetobuffer(buf) 
1605          try: self.__field_msg 
1606          except: 
1607              self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx6000_183, 'length': 219}) 
1608          self.__field_msg.writetobuffer(buf) 
1609          self._bufferendoffset=buf.getcurrentoffset() 
1610          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1611   
1612   
1613 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1614          'Reads this packet from the supplied buffer' 
1615          self._bufferstartoffset=buf.getcurrentoffset() 
1616          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1617          self.__field_unknown1=UINT(**{'sizeinbytes': 1}) 
1618          self.__field_unknown1.readfrombuffer(buf) 
1619          self.__field_binary=UINT(**{'sizeinbytes': 1}) 
1620          self.__field_binary.readfrombuffer(buf) 
1621          self.__field_unknown3=UINT(**{'sizeinbytes': 1}) 
1622          self.__field_unknown3.readfrombuffer(buf) 
1623          self.__field_unknown4=UINT(**{'sizeinbytes': 1}) 
1624          self.__field_unknown4.readfrombuffer(buf) 
1625          self.__field_unknown6=UINT(**{'sizeinbytes': 1}) 
1626          self.__field_unknown6.readfrombuffer(buf) 
1627          self.__field_length=UINT(**{'sizeinbytes': 1}) 
1628          self.__field_length.readfrombuffer(buf) 
1629          self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx6000_183, 'length': 219}) 
1630          self.__field_msg.readfrombuffer(buf) 
1631          self._bufferendoffset=buf.getcurrentoffset() 
1632   
1633   
1634 -    def __getfield_unknown1(self): 
1635          return self.__field_unknown1.getvalue() 
1636   
1637 -    def __setfield_unknown1(self, value): 
1638          if isinstance(value,UINT): 
1639              self.__field_unknown1=value 
1640          else: 
1641              self.__field_unknown1=UINT(value,**{'sizeinbytes': 1}) 
1642   
1643 -    def __delfield_unknown1(self): del self.__field_unknown1 
1644   
1645      unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 
1646   
1647 -    def __getfield_binary(self): 
1648          return self.__field_binary.getvalue() 
1649   
1650 -    def __setfield_binary(self, value): 
1651          if isinstance(value,UINT): 
1652              self.__field_binary=value 
1653          else: 
1654              self.__field_binary=UINT(value,**{'sizeinbytes': 1}) 
1655   
1656 -    def __delfield_binary(self): del self.__field_binary 
1657   
1658      binary=property(__getfield_binary, __setfield_binary, __delfield_binary, None) 
1659   
1660 -    def __getfield_unknown3(self): 
1661          return self.__field_unknown3.getvalue() 
1662   
1663 -    def __setfield_unknown3(self, value): 
1664          if isinstance(value,UINT): 
1665              self.__field_unknown3=value 
1666          else: 
1667              self.__field_unknown3=UINT(value,**{'sizeinbytes': 1}) 
1668   
1669 -    def __delfield_unknown3(self): del self.__field_unknown3 
1670   
1671      unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None) 
1672   
1673 -    def __getfield_unknown4(self): 
1674          return self.__field_unknown4.getvalue() 
1675   
1676 -    def __setfield_unknown4(self, value): 
1677          if isinstance(value,UINT): 
1678              self.__field_unknown4=value 
1679          else: 
1680              self.__field_unknown4=UINT(value,**{'sizeinbytes': 1}) 
1681   
1682 -    def __delfield_unknown4(self): del self.__field_unknown4 
1683   
1684      unknown4=property(__getfield_unknown4, __setfield_unknown4, __delfield_unknown4, None) 
1685   
1686 -    def __getfield_unknown6(self): 
1687          return self.__field_unknown6.getvalue() 
1688   
1689 -    def __setfield_unknown6(self, value): 
1690          if isinstance(value,UINT): 
1691              self.__field_unknown6=value 
1692          else: 
1693              self.__field_unknown6=UINT(value,**{'sizeinbytes': 1}) 
1694   
1695 -    def __delfield_unknown6(self): del self.__field_unknown6 
1696   
1697      unknown6=property(__getfield_unknown6, __setfield_unknown6, __delfield_unknown6, None) 
1698   
1699 -    def __getfield_length(self): 
1700          return self.__field_length.getvalue() 
1701   
1702 -    def __setfield_length(self, value): 
1703          if isinstance(value,UINT): 
1704              self.__field_length=value 
1705          else: 
1706              self.__field_length=UINT(value,**{'sizeinbytes': 1}) 
1707   
1708 -    def __delfield_length(self): del self.__field_length 
1709   
1710      length=property(__getfield_length, __setfield_length, __delfield_length, None) 
1711   
1712 -    def __getfield_msg(self): 
1713          try: self.__field_msg 
1714          except: 
1715              self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx6000_183, 'length': 219}) 
1716          return self.__field_msg.getvalue() 
1717   
1718 -    def __setfield_msg(self, value): 
1719          if isinstance(value,LIST): 
1720              self.__field_msg=value 
1721          else: 
1722              self.__field_msg=LIST(value,**{'elementclass': _gen_p_lgvx6000_183, 'length': 219}) 
1723   
1724 -    def __delfield_msg(self): del self.__field_msg 
1725   
1726      msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None) 
1727   
1728 -    def iscontainer(self): 
1729          return True 
1730   
1731 -    def containerelements(self): 
1732          yield ('unknown1', self.__field_unknown1, None) 
1733          yield ('binary', self.__field_binary, None) 
1734          yield ('unknown3', self.__field_unknown3, None) 
1735          yield ('unknown4', self.__field_unknown4, None) 
1736          yield ('unknown6', self.__field_unknown6, None) 
1737          yield ('length', self.__field_length, None) 
1738          yield ('msg', self.__field_msg, None) 
1739   
1740   
1741   
1742   
1743 -class _gen_p_lgvx6000_183(BaseProtogenClass): 
1744      'Anonymous inner class' 
1745      __fields=['byte'] 
1746   
1747 -    def __init__(self, *args, **kwargs): 
1748          dict={} 
1749          # What was supplied to this function 
1750          dict.update(kwargs) 
1751          # Parent constructor 
1752          super(_gen_p_lgvx6000_183,self).__init__(**dict) 
1753          if self.__class__ is _gen_p_lgvx6000_183: 
1754              self._update(args,dict) 
1755   
1756   
1757 -    def getfields(self): 
1758          return self.__fields 
1759   
1760   
1761 -    def _update(self, args, kwargs): 
1762          super(_gen_p_lgvx6000_183,self)._update(args,kwargs) 
1763          keys=kwargs.keys() 
1764          for key in keys: 
1765              if key in self.__fields: 
1766                  setattr(self, key, kwargs[key]) 
1767                  del kwargs[key] 
1768          # Were any unrecognized kwargs passed in? 
1769          if __debug__: 
1770              self._complainaboutunusedargs(_gen_p_lgvx6000_183,kwargs) 
1771          if len(args): 
1772              dict2={'sizeinbytes': 1} 
1773              dict2.update(kwargs) 
1774              kwargs=dict2 
1775              self.__field_byte=UINT(*args,**dict2) 
1776          # Make all P fields that haven't already been constructed 
1777   
1778   
1779 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1780          'Writes this packet to the supplied buffer' 
1781          self._bufferstartoffset=buf.getcurrentoffset() 
1782          self.__field_byte.writetobuffer(buf) 
1783          self._bufferendoffset=buf.getcurrentoffset() 
1784          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1785   
1786   
1787 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1788          'Reads this packet from the supplied buffer' 
1789          self._bufferstartoffset=buf.getcurrentoffset() 
1790          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1791          self.__field_byte=UINT(**{'sizeinbytes': 1}) 
1792          self.__field_byte.readfrombuffer(buf) 
1793          self._bufferendoffset=buf.getcurrentoffset() 
1794   
1795   
1796 -    def __getfield_byte(self): 
1797          return self.__field_byte.getvalue() 
1798   
1799 -    def __setfield_byte(self, value): 
1800          if isinstance(value,UINT): 
1801              self.__field_byte=value 
1802          else: 
1803              self.__field_byte=UINT(value,**{'sizeinbytes': 1}) 
1804   
1805 -    def __delfield_byte(self): del self.__field_byte 
1806   
1807      byte=property(__getfield_byte, __setfield_byte, __delfield_byte, "individual byte of message") 
1808   
1809 -    def iscontainer(self): 
1810          return True 
1811   
1812 -    def containerelements(self): 
1813          yield ('byte', self.__field_byte, "individual byte of message") 
1814   
1815   
1816   
1817   
1818 -class recipient_record(BaseProtogenClass): 
1819      __fields=['unknown1', 'number', 'status', 'timesent', 'timereceived', 'unknown2'] 
1820   
1821 -    def __init__(self, *args, **kwargs): 
1822          dict={} 
1823          # What was supplied to this function 
1824          dict.update(kwargs) 
1825          # Parent constructor 
1826          super(recipient_record,self).__init__(**dict) 
1827          if self.__class__ is recipient_record: 
1828              self._update(args,dict) 
1829   
1830   
1831 -    def getfields(self): 
1832          return self.__fields 
1833   
1834   
1835 -    def _update(self, args, kwargs): 
1836          super(recipient_record,self)._update(args,kwargs) 
1837          keys=kwargs.keys() 
1838          for key in keys: 
1839              if key in self.__fields: 
1840                  setattr(self, key, kwargs[key]) 
1841                  del kwargs[key] 
1842          # Were any unrecognized kwargs passed in? 
1843          if __debug__: 
1844              self._complainaboutunusedargs(recipient_record,kwargs) 
1845          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1846          # Make all P fields that haven't already been constructed 
1847   
1848   
1849 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1850          'Writes this packet to the supplied buffer' 
1851          self._bufferstartoffset=buf.getcurrentoffset() 
1852          self.__field_unknown1.writetobuffer(buf) 
1853          self.__field_number.writetobuffer(buf) 
1854          self.__field_status.writetobuffer(buf) 
1855          self.__field_timesent.writetobuffer(buf) 
1856          self.__field_timereceived.writetobuffer(buf) 
1857          self.__field_unknown2.writetobuffer(buf) 
1858          self._bufferendoffset=buf.getcurrentoffset() 
1859          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1860   
1861   
1862 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1863          'Reads this packet from the supplied buffer' 
1864          self._bufferstartoffset=buf.getcurrentoffset() 
1865          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1866          self.__field_unknown1=UINT(**{'sizeinbytes': 2}) 
1867          self.__field_unknown1.readfrombuffer(buf) 
1868          self.__field_number=USTRING(**{'sizeinbytes': 49}) 
1869          self.__field_number.readfrombuffer(buf) 
1870          self.__field_status=UINT(**{'sizeinbytes': 1}) 
1871          self.__field_status.readfrombuffer(buf) 
1872          self.__field_timesent=LGCALDATE(**{'sizeinbytes': 4}) 
1873          self.__field_timesent.readfrombuffer(buf) 
1874          self.__field_timereceived=LGCALDATE(**{'sizeinbytes': 4}) 
1875          self.__field_timereceived.readfrombuffer(buf) 
1876          self.__field_unknown2=DATA(**{'sizeinbytes': 8}) 
1877          self.__field_unknown2.readfrombuffer(buf) 
1878          self._bufferendoffset=buf.getcurrentoffset() 
1879   
1880   
1881 -    def __getfield_unknown1(self): 
1882          return self.__field_unknown1.getvalue() 
1883   
1884 -    def __setfield_unknown1(self, value): 
1885          if isinstance(value,UINT): 
1886              self.__field_unknown1=value 
1887          else: 
1888              self.__field_unknown1=UINT(value,**{'sizeinbytes': 2}) 
1889   
1890 -    def __delfield_unknown1(self): del self.__field_unknown1 
1891   
1892      unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 
1893   
1894 -    def __getfield_number(self): 
1895          return self.__field_number.getvalue() 
1896   
1897 -    def __setfield_number(self, value): 
1898          if isinstance(value,USTRING): 
1899              self.__field_number=value 
1900          else: 
1901              self.__field_number=USTRING(value,**{'sizeinbytes': 49}) 
1902   
1903 -    def __delfield_number(self): del self.__field_number 
1904   
1905      number=property(__getfield_number, __setfield_number, __delfield_number, None) 
1906   
1907 -    def __getfield_status(self): 
1908          return self.__field_status.getvalue() 
1909   
1910 -    def __setfield_status(self, value): 
1911          if isinstance(value,UINT): 
1912              self.__field_status=value 
1913          else: 
1914              self.__field_status=UINT(value,**{'sizeinbytes': 1}) 
1915   
1916 -    def __delfield_status(self): del self.__field_status 
1917   
1918      status=property(__getfield_status, __setfield_status, __delfield_status, None) 
1919   
1920 -    def __getfield_timesent(self): 
1921          return self.__field_timesent.getvalue() 
1922   
1923 -    def __setfield_timesent(self, value): 
1924          if isinstance(value,LGCALDATE): 
1925              self.__field_timesent=value 
1926          else: 
1927              self.__field_timesent=LGCALDATE(value,**{'sizeinbytes': 4}) 
1928   
1929 -    def __delfield_timesent(self): del self.__field_timesent 
1930   
1931      timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None) 
1932   
1933 -    def __getfield_timereceived(self): 
1934          return self.__field_timereceived.getvalue() 
1935   
1936 -    def __setfield_timereceived(self, value): 
1937          if isinstance(value,LGCALDATE): 
1938              self.__field_timereceived=value 
1939          else: 
1940              self.__field_timereceived=LGCALDATE(value,**{'sizeinbytes': 4}) 
1941   
1942 -    def __delfield_timereceived(self): del self.__field_timereceived 
1943   
1944      timereceived=property(__getfield_timereceived, __setfield_timereceived, __delfield_timereceived, None) 
1945   
1946 -    def __getfield_unknown2(self): 
1947          return self.__field_unknown2.getvalue() 
1948   
1949 -    def __setfield_unknown2(self, value): 
1950          if isinstance(value,DATA): 
1951              self.__field_unknown2=value 
1952          else: 
1953              self.__field_unknown2=DATA(value,**{'sizeinbytes': 8}) 
1954   
1955 -    def __delfield_unknown2(self): del self.__field_unknown2 
1956   
1957      unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None) 
1958   
1959 -    def iscontainer(self): 
1960          return True 
1961   
1962 -    def containerelements(self): 
1963          yield ('unknown1', self.__field_unknown1, None) 
1964          yield ('number', self.__field_number, None) 
1965          yield ('status', self.__field_status, None) 
1966          yield ('timesent', self.__field_timesent, None) 
1967          yield ('timereceived', self.__field_timereceived, None) 
1968          yield ('unknown2', self.__field_unknown2, None) 
1969   
1970   
1971   
1972   
1973 -class sms_saved(BaseProtogenClass): 
1974      __fields=['outboxmsg', 'pad', 'outbox', 'inbox'] 
1975   
1976 -    def __init__(self, *args, **kwargs): 
1977          dict={} 
1978          # What was supplied to this function 
1979          dict.update(kwargs) 
1980          # Parent constructor 
1981          super(sms_saved,self).__init__(**dict) 
1982          if self.__class__ is sms_saved: 
1983              self._update(args,dict) 
1984   
1985   
1986 -    def getfields(self): 
1987          return self.__fields 
1988   
1989   
1990 -    def _update(self, args, kwargs): 
1991          super(sms_saved,self)._update(args,kwargs) 
1992          keys=kwargs.keys() 
1993          for key in keys: 
1994              if key in self.__fields: 
1995                  setattr(self, key, kwargs[key]) 
1996                  del kwargs[key] 
1997          # Were any unrecognized kwargs passed in? 
1998          if __debug__: 
1999              self._complainaboutunusedargs(sms_saved,kwargs) 
2000          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2001          # Make all P fields that haven't already been constructed 
2002   
2003   
2004 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2005          'Writes this packet to the supplied buffer' 
2006          self._bufferstartoffset=buf.getcurrentoffset() 
2007          self.__field_outboxmsg.writetobuffer(buf) 
2008          self.__field_pad.writetobuffer(buf) 
2009          if self.outboxmsg: 
2010              self.__field_outbox.writetobuffer(buf) 
2011          if not self.outboxmsg: 
2012              self.__field_inbox.writetobuffer(buf) 
2013          self._bufferendoffset=buf.getcurrentoffset() 
2014          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2015   
2016   
2017 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2018          'Reads this packet from the supplied buffer' 
2019          self._bufferstartoffset=buf.getcurrentoffset() 
2020          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2021          self.__field_outboxmsg=UINT(**{'sizeinbytes': 4}) 
2022          self.__field_outboxmsg.readfrombuffer(buf) 
2023          self.__field_pad=UNKNOWN(**{'sizeinbytes': 4}) 
2024          self.__field_pad.readfrombuffer(buf) 
2025          if self.outboxmsg: 
2026              self.__field_outbox=sms_out() 
2027              self.__field_outbox.readfrombuffer(buf) 
2028          if not self.outboxmsg: 
2029              self.__field_inbox=sms_in() 
2030              self.__field_inbox.readfrombuffer(buf) 
2031          self._bufferendoffset=buf.getcurrentoffset() 
2032   
2033   
2034 -    def __getfield_outboxmsg(self): 
2035          return self.__field_outboxmsg.getvalue() 
2036   
2037 -    def __setfield_outboxmsg(self, value): 
2038          if isinstance(value,UINT): 
2039              self.__field_outboxmsg=value 
2040          else: 
2041              self.__field_outboxmsg=UINT(value,**{'sizeinbytes': 4}) 
2042   
2043 -    def __delfield_outboxmsg(self): del self.__field_outboxmsg 
2044   
2045      outboxmsg=property(__getfield_outboxmsg, __setfield_outboxmsg, __delfield_outboxmsg, None) 
2046   
2047 -    def __getfield_pad(self): 
2048          return self.__field_pad.getvalue() 
2049   
2050 -    def __setfield_pad(self, value): 
2051          if isinstance(value,UNKNOWN): 
2052              self.__field_pad=value 
2053          else: 
2054              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 4}) 
2055   
2056 -    def __delfield_pad(self): del self.__field_pad 
2057   
2058      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
2059   
2060 -    def __getfield_outbox(self): 
2061          return self.__field_outbox.getvalue() 
2062   
2063 -    def __setfield_outbox(self, value): 
2064          if isinstance(value,sms_out): 
2065              self.__field_outbox=value 
2066          else: 
2067              self.__field_outbox=sms_out(value,) 
2068   
2069 -    def __delfield_outbox(self): del self.__field_outbox 
2070   
2071      outbox=property(__getfield_outbox, __setfield_outbox, __delfield_outbox, None) 
2072   
2073 -    def __getfield_inbox(self): 
2074          return self.__field_inbox.getvalue() 
2075   
2076 -    def __setfield_inbox(self, value): 
2077          if isinstance(value,sms_in): 
2078              self.__field_inbox=value 
2079          else: 
2080              self.__field_inbox=sms_in(value,) 
2081   
2082 -    def __delfield_inbox(self): del self.__field_inbox 
2083   
2084      inbox=property(__getfield_inbox, __setfield_inbox, __delfield_inbox, None) 
2085   
2086 -    def iscontainer(self): 
2087          return True 
2088   
2089 -    def containerelements(self): 
2090          yield ('outboxmsg', self.__field_outboxmsg, None) 
2091          yield ('pad', self.__field_pad, None) 
2092          if self.outboxmsg: 
2093              yield ('outbox', self.__field_outbox, None) 
2094          if not self.outboxmsg: 
2095              yield ('inbox', self.__field_inbox, None) 
2096   
2097   
2098   
2099   
2100 -class sms_out(BaseProtogenClass): 
2101      __fields=['callback', 'index', 'locked', 'unknown1', 'timesent', 'subject', 'unknown2', 'num_msg_elements', 'messages', 'unknown5', 'priority', 'unknown7', 'recipients'] 
2102   
2103 -    def __init__(self, *args, **kwargs): 
2104          dict={} 
2105          # What was supplied to this function 
2106          dict.update(kwargs) 
2107          # Parent constructor 
2108          super(sms_out,self).__init__(**dict) 
2109          if self.__class__ is sms_out: 
2110              self._update(args,dict) 
2111   
2112   
2113 -    def getfields(self): 
2114          return self.__fields 
2115   
2116   
2117 -    def _update(self, args, kwargs): 
2118          super(sms_out,self)._update(args,kwargs) 
2119          keys=kwargs.keys() 
2120          for key in keys: 
2121              if key in self.__fields: 
2122                  setattr(self, key, kwargs[key]) 
2123                  del kwargs[key] 
2124          # Were any unrecognized kwargs passed in? 
2125          if __debug__: 
2126              self._complainaboutunusedargs(sms_out,kwargs) 
2127          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2128          # Make all P fields that haven't already been constructed 
2129          try: self.__field_callback 
2130          except: 
2131              self.__field_callback=USTRING(**{ 'default': '' }) 
2132   
2133   
2134 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2135          'Writes this packet to the supplied buffer' 
2136          self._bufferstartoffset=buf.getcurrentoffset() 
2137          self.__field_index.writetobuffer(buf) 
2138          self.__field_locked.writetobuffer(buf) 
2139          self.__field_unknown1.writetobuffer(buf) 
2140          self.__field_timesent.writetobuffer(buf) 
2141          self.__field_subject.writetobuffer(buf) 
2142          self.__field_unknown2.writetobuffer(buf) 
2143          self.__field_num_msg_elements.writetobuffer(buf) 
2144          try: self.__field_messages 
2145          except: 
2146              self.__field_messages=LIST(**{'elementclass': msg_record, 'length': 10}) 
2147          self.__field_messages.writetobuffer(buf) 
2148          self.__field_unknown5.writetobuffer(buf) 
2149          self.__field_priority.writetobuffer(buf) 
2150          self.__field_unknown7.writetobuffer(buf) 
2151          try: self.__field_recipients 
2152          except: 
2153              self.__field_recipients=LIST(**{'elementclass': recipient_record,'length': 10}) 
2154          self.__field_recipients.writetobuffer(buf) 
2155          self._bufferendoffset=buf.getcurrentoffset() 
2156          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2157   
2158   
2159 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2160          'Reads this packet from the supplied buffer' 
2161          self._bufferstartoffset=buf.getcurrentoffset() 
2162          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2163          self.__field_index=UINT(**{'sizeinbytes': 4}) 
2164          self.__field_index.readfrombuffer(buf) 
2165          self.__field_locked=UINT(**{'sizeinbytes': 1}) 
2166          self.__field_locked.readfrombuffer(buf) 
2167          self.__field_unknown1=UINT(**{'sizeinbytes': 3}) 
2168          self.__field_unknown1.readfrombuffer(buf) 
2169          self.__field_timesent=LGCALDATE(**{'sizeinbytes': 4}) 
2170          self.__field_timesent.readfrombuffer(buf) 
2171          self.__field_subject=USTRING(**{'sizeinbytes': 21}) 
2172          self.__field_subject.readfrombuffer(buf) 
2173          self.__field_unknown2=DATA(**{'sizeinbytes': 151}) 
2174          self.__field_unknown2.readfrombuffer(buf) 
2175          self.__field_num_msg_elements=UINT(**{'sizeinbytes': 1}) 
2176          self.__field_num_msg_elements.readfrombuffer(buf) 
2177          self.__field_messages=LIST(**{'elementclass': msg_record, 'length': 10}) 
2178          self.__field_messages.readfrombuffer(buf) 
2179          self.__field_unknown5=UINT(**{'sizeinbytes': 1}) 
2180          self.__field_unknown5.readfrombuffer(buf) 
2181          self.__field_priority=UINT(**{'sizeinbytes': 1}) 
2182          self.__field_priority.readfrombuffer(buf) 
2183          self.__field_unknown7=DATA(**{'sizeinbytes': 39}) 
2184          self.__field_unknown7.readfrombuffer(buf) 
2185          self.__field_recipients=LIST(**{'elementclass': recipient_record,'length': 10}) 
2186          self.__field_recipients.readfrombuffer(buf) 
2187          self._bufferendoffset=buf.getcurrentoffset() 
2188   
2189   
2190 -    def __getfield_callback(self): 
2191          return self.__field_callback.getvalue() 
2192   
2193 -    def __setfield_callback(self, value): 
2194          if isinstance(value,USTRING): 
2195              self.__field_callback=value 
2196          else: 
2197              self.__field_callback=USTRING(value,**{ 'default': '' }) 
2198   
2199 -    def __delfield_callback(self): del self.__field_callback 
2200   
2201      callback=property(__getfield_callback, __setfield_callback, __delfield_callback, None) 
2202   
2203 -    def __getfield_index(self): 
2204          return self.__field_index.getvalue() 
2205   
2206 -    def __setfield_index(self, value): 
2207          if isinstance(value,UINT): 
2208              self.__field_index=value 
2209          else: 
2210              self.__field_index=UINT(value,**{'sizeinbytes': 4}) 
2211   
2212 -    def __delfield_index(self): del self.__field_index 
2213   
2214      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
2215   
2216 -    def __getfield_locked(self): 
2217          return self.__field_locked.getvalue() 
2218   
2219 -    def __setfield_locked(self, value): 
2220          if isinstance(value,UINT): 
2221              self.__field_locked=value 
2222          else: 
2223              self.__field_locked=UINT(value,**{'sizeinbytes': 1}) 
2224   
2225 -    def __delfield_locked(self): del self.__field_locked 
2226   
2227      locked=property(__getfield_locked, __setfield_locked, __delfield_locked, None) 
2228   
2229 -    def __getfield_unknown1(self): 
2230          return self.__field_unknown1.getvalue() 
2231   
2232 -    def __setfield_unknown1(self, value): 
2233          if isinstance(value,UINT): 
2234              self.__field_unknown1=value 
2235          else: 
2236              self.__field_unknown1=UINT(value,**{'sizeinbytes': 3}) 
2237   
2238 -    def __delfield_unknown1(self): del self.__field_unknown1 
2239   
2240      unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 
2241   
2242 -    def __getfield_timesent(self): 
2243          return self.__field_timesent.getvalue() 
2244   
2245 -    def __setfield_timesent(self, value): 
2246          if isinstance(value,LGCALDATE): 
2247              self.__field_timesent=value 
2248          else: 
2249              self.__field_timesent=LGCALDATE(value,**{'sizeinbytes': 4}) 
2250   
2251 -    def __delfield_timesent(self): del self.__field_timesent 
2252   
2253      timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None) 
2254   
2255 -    def __getfield_subject(self): 
2256          return self.__field_subject.getvalue() 
2257   
2258 -    def __setfield_subject(self, value): 
2259          if isinstance(value,USTRING): 
2260              self.__field_subject=value 
2261          else: 
2262              self.__field_subject=USTRING(value,**{'sizeinbytes': 21}) 
2263   
2264 -    def __delfield_subject(self): del self.__field_subject 
2265   
2266      subject=property(__getfield_subject, __setfield_subject, __delfield_subject, None) 
2267   
2268 -    def __getfield_unknown2(self): 
2269          return self.__field_unknown2.getvalue() 
2270   
2271 -    def __setfield_unknown2(self, value): 
2272          if isinstance(value,DATA): 
2273              self.__field_unknown2=value 
2274          else: 
2275              self.__field_unknown2=DATA(value,**{'sizeinbytes': 151}) 
2276   
2277 -    def __delfield_unknown2(self): del self.__field_unknown2 
2278   
2279      unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None) 
2280   
2281 -    def __getfield_num_msg_elements(self): 
2282          return self.__field_num_msg_elements.getvalue() 
2283   
2284 -    def __setfield_num_msg_elements(self, value): 
2285          if isinstance(value,UINT): 
2286              self.__field_num_msg_elements=value 
2287          else: 
2288              self.__field_num_msg_elements=UINT(value,**{'sizeinbytes': 1}) 
2289   
2290 -    def __delfield_num_msg_elements(self): del self.__field_num_msg_elements 
2291   
2292      num_msg_elements=property(__getfield_num_msg_elements, __setfield_num_msg_elements, __delfield_num_msg_elements, None) 
2293   
2294 -    def __getfield_messages(self): 
2295          try: self.__field_messages 
2296          except: 
2297              self.__field_messages=LIST(**{'elementclass': msg_record, 'length': 10}) 
2298          return self.__field_messages.getvalue() 
2299   
2300 -    def __setfield_messages(self, value): 
2301          if isinstance(value,LIST): 
2302              self.__field_messages=value 
2303          else: 
2304              self.__field_messages=LIST(value,**{'elementclass': msg_record, 'length': 10}) 
2305   
2306 -    def __delfield_messages(self): del self.__field_messages 
2307   
2308      messages=property(__getfield_messages, __setfield_messages, __delfield_messages, None) 
2309   
2310 -    def __getfield_unknown5(self): 
2311          return self.__field_unknown5.getvalue() 
2312   
2313 -    def __setfield_unknown5(self, value): 
2314          if isinstance(value,UINT): 
2315              self.__field_unknown5=value 
2316          else: 
2317              self.__field_unknown5=UINT(value,**{'sizeinbytes': 1}) 
2318   
2319 -    def __delfield_unknown5(self): del self.__field_unknown5 
2320   
2321      unknown5=property(__getfield_unknown5, __setfield_unknown5, __delfield_unknown5, None) 
2322   
2323 -    def __getfield_priority(self): 
2324          return self.__field_priority.getvalue() 
2325   
2326 -    def __setfield_priority(self, value): 
2327          if isinstance(value,UINT): 
2328              self.__field_priority=value 
2329          else: 
2330              self.__field_priority=UINT(value,**{'sizeinbytes': 1}) 
2331   
2332 -    def __delfield_priority(self): del self.__field_priority 
2333   
2334      priority=property(__getfield_priority, __setfield_priority, __delfield_priority, None) 
2335   
2336 -    def __getfield_unknown7(self): 
2337          return self.__field_unknown7.getvalue() 
2338   
2339 -    def __setfield_unknown7(self, value): 
2340          if isinstance(value,DATA): 
2341              self.__field_unknown7=value 
2342          else: 
2343              self.__field_unknown7=DATA(value,**{'sizeinbytes': 39}) 
2344   
2345 -    def __delfield_unknown7(self): del self.__field_unknown7 
2346   
2347      unknown7=property(__getfield_unknown7, __setfield_unknown7, __delfield_unknown7, None) 
2348   
2349 -    def __getfield_recipients(self): 
2350          try: self.__field_recipients 
2351          except: 
2352              self.__field_recipients=LIST(**{'elementclass': recipient_record,'length': 10}) 
2353          return self.__field_recipients.getvalue() 
2354   
2355 -    def __setfield_recipients(self, value): 
2356          if isinstance(value,LIST): 
2357              self.__field_recipients=value 
2358          else: 
2359              self.__field_recipients=LIST(value,**{'elementclass': recipient_record,'length': 10}) 
2360   
2361 -    def __delfield_recipients(self): del self.__field_recipients 
2362   
2363      recipients=property(__getfield_recipients, __setfield_recipients, __delfield_recipients, None) 
2364   
2365 -    def iscontainer(self): 
2366          return True 
2367   
2368 -    def containerelements(self): 
2369          yield ('callback', self.__field_callback, None) 
2370          yield ('index', self.__field_index, None) 
2371          yield ('locked', self.__field_locked, None) 
2372          yield ('unknown1', self.__field_unknown1, None) 
2373          yield ('timesent', self.__field_timesent, None) 
2374          yield ('subject', self.__field_subject, None) 
2375          yield ('unknown2', self.__field_unknown2, None) 
2376          yield ('num_msg_elements', self.__field_num_msg_elements, None) 
2377          yield ('messages', self.__field_messages, None) 
2378          yield ('unknown5', self.__field_unknown5, None) 
2379          yield ('priority', self.__field_priority, None) 
2380          yield ('unknown7', self.__field_unknown7, None) 
2381          yield ('recipients', self.__field_recipients, None) 
2382   
2383   
2384   
2385   
2386 -class SMSINBOXMSGFRAGMENT(BaseProtogenClass): 
2387      __fields=['msg'] 
2388   
2389 -    def __init__(self, *args, **kwargs): 
2390          dict={} 
2391          # What was supplied to this function 
2392          dict.update(kwargs) 
2393          # Parent constructor 
2394          super(SMSINBOXMSGFRAGMENT,self).__init__(**dict) 
2395          if self.__class__ is SMSINBOXMSGFRAGMENT: 
2396              self._update(args,dict) 
2397   
2398   
2399 -    def getfields(self): 
2400          return self.__fields 
2401   
2402   
2403 -    def _update(self, args, kwargs): 
2404          super(SMSINBOXMSGFRAGMENT,self)._update(args,kwargs) 
2405          keys=kwargs.keys() 
2406          for key in keys: 
2407              if key in self.__fields: 
2408                  setattr(self, key, kwargs[key]) 
2409                  del kwargs[key] 
2410          # Were any unrecognized kwargs passed in? 
2411          if __debug__: 
2412              self._complainaboutunusedargs(SMSINBOXMSGFRAGMENT,kwargs) 
2413          if len(args): 
2414              dict2={'elementclass': _gen_p_lgvx6000_218, 'length': 181} 
2415              dict2.update(kwargs) 
2416              kwargs=dict2 
2417              self.__field_msg=LIST(*args,**dict2) 
2418          # Make all P fields that haven't already been constructed 
2419   
2420   
2421 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2422          'Writes this packet to the supplied buffer' 
2423          self._bufferstartoffset=buf.getcurrentoffset() 
2424          try: self.__field_msg 
2425          except: 
2426              self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx6000_218, 'length': 181}) 
2427          self.__field_msg.writetobuffer(buf) 
2428          self._bufferendoffset=buf.getcurrentoffset() 
2429          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2430   
2431   
2432 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2433          'Reads this packet from the supplied buffer' 
2434          self._bufferstartoffset=buf.getcurrentoffset() 
2435          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2436          self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx6000_218, 'length': 181}) 
2437          self.__field_msg.readfrombuffer(buf) 
2438          self._bufferendoffset=buf.getcurrentoffset() 
2439   
2440   
2441 -    def __getfield_msg(self): 
2442          try: self.__field_msg 
2443          except: 
2444              self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx6000_218, 'length': 181}) 
2445          return self.__field_msg.getvalue() 
2446   
2447 -    def __setfield_msg(self, value): 
2448          if isinstance(value,LIST): 
2449              self.__field_msg=value 
2450          else: 
2451              self.__field_msg=LIST(value,**{'elementclass': _gen_p_lgvx6000_218, 'length': 181}) 
2452   
2453 -    def __delfield_msg(self): del self.__field_msg 
2454   
2455      msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None) 
2456   
2457 -    def iscontainer(self): 
2458          return True 
2459   
2460 -    def containerelements(self): 
2461          yield ('msg', self.__field_msg, None) 
2462   
2463   
2464   
2465   
2466 -class _gen_p_lgvx6000_218(BaseProtogenClass): 
2467      'Anonymous inner class' 
2468      __fields=['byte'] 
2469   
2470 -    def __init__(self, *args, **kwargs): 
2471          dict={} 
2472          # What was supplied to this function 
2473          dict.update(kwargs) 
2474          # Parent constructor 
2475          super(_gen_p_lgvx6000_218,self).__init__(**dict) 
2476          if self.__class__ is _gen_p_lgvx6000_218: 
2477              self._update(args,dict) 
2478   
2479   
2480 -    def getfields(self): 
2481          return self.__fields 
2482   
2483   
2484 -    def _update(self, args, kwargs): 
2485          super(_gen_p_lgvx6000_218,self)._update(args,kwargs) 
2486          keys=kwargs.keys() 
2487          for key in keys: 
2488              if key in self.__fields: 
2489                  setattr(self, key, kwargs[key]) 
2490                  del kwargs[key] 
2491          # Were any unrecognized kwargs passed in? 
2492          if __debug__: 
2493              self._complainaboutunusedargs(_gen_p_lgvx6000_218,kwargs) 
2494          if len(args): 
2495              dict2={'sizeinbytes': 1} 
2496              dict2.update(kwargs) 
2497              kwargs=dict2 
2498              self.__field_byte=UINT(*args,**dict2) 
2499          # Make all P fields that haven't already been constructed 
2500   
2501   
2502 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2503          'Writes this packet to the supplied buffer' 
2504          self._bufferstartoffset=buf.getcurrentoffset() 
2505          self.__field_byte.writetobuffer(buf) 
2506          self._bufferendoffset=buf.getcurrentoffset() 
2507          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2508   
2509   
2510 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2511          'Reads this packet from the supplied buffer' 
2512          self._bufferstartoffset=buf.getcurrentoffset() 
2513          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2514          self.__field_byte=UINT(**{'sizeinbytes': 1}) 
2515          self.__field_byte.readfrombuffer(buf) 
2516          self._bufferendoffset=buf.getcurrentoffset() 
2517   
2518   
2519 -    def __getfield_byte(self): 
2520          return self.__field_byte.getvalue() 
2521   
2522 -    def __setfield_byte(self, value): 
2523          if isinstance(value,UINT): 
2524              self.__field_byte=value 
2525          else: 
2526              self.__field_byte=UINT(value,**{'sizeinbytes': 1}) 
2527   
2528 -    def __delfield_byte(self): del self.__field_byte 
2529   
2530      byte=property(__getfield_byte, __setfield_byte, __delfield_byte, "individual byte of message") 
2531   
2532 -    def iscontainer(self): 
2533          return True 
2534   
2535 -    def containerelements(self): 
2536          yield ('byte', self.__field_byte, "individual byte of message") 
2537   
2538   
2539   
2540   
2541 -class sms_in(BaseProtogenClass): 
2542      __fields=['msg_index1', 'msg_index2', 'unknown2', 'unknown3', 'timesent', 'unknown', 'callback_length', 'callback', 'sender_length', 'sender', 'unknown4', 'lg_time', 'GPStime', 'unknown5', 'read', 'locked', 'unknown8', 'priority', 'flags', 'subject', 'bin_header1', 'bin_header2', 'unknown6', 'multipartID', 'bin_header3', 'num_msg_elements', 'msglengths', 'msgs', 'unknown5', 'senders_name', 'unknown6'] 
2543   
2544 -    def __init__(self, *args, **kwargs): 
2545          dict={} 
2546          # What was supplied to this function 
2547          dict.update(kwargs) 
2548          # Parent constructor 
2549          super(sms_in,self).__init__(**dict) 
2550          if self.__class__ is sms_in: 
2551              self._update(args,dict) 
2552   
2553   
2554 -    def getfields(self): 
2555          return self.__fields 
2556   
2557   
2558 -    def _update(self, args, kwargs): 
2559          super(sms_in,self)._update(args,kwargs) 
2560          keys=kwargs.keys() 
2561          for key in keys: 
2562              if key in self.__fields: 
2563                  setattr(self, key, kwargs[key]) 
2564                  del kwargs[key] 
2565          # Were any unrecognized kwargs passed in? 
2566          if __debug__: 
2567              self._complainaboutunusedargs(sms_in,kwargs) 
2568          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2569          # Make all P fields that haven't already been constructed 
2570   
2571   
2572 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2573          'Writes this packet to the supplied buffer' 
2574          self._bufferstartoffset=buf.getcurrentoffset() 
2575          self.__field_msg_index1.writetobuffer(buf) 
2576          self.__field_msg_index2.writetobuffer(buf) 
2577          self.__field_unknown2.writetobuffer(buf) 
2578          self.__field_unknown3.writetobuffer(buf) 
2579          self.__field_timesent.writetobuffer(buf) 
2580          self.__field_unknown.writetobuffer(buf) 
2581          self.__field_callback_length.writetobuffer(buf) 
2582          self.__field_callback.writetobuffer(buf) 
2583          self.__field_sender_length.writetobuffer(buf) 
2584          try: self.__field_sender 
2585          except: 
2586              self.__field_sender=LIST(**{'elementclass': _gen_p_lgvx6000_231, 'length': 38}) 
2587          self.__field_sender.writetobuffer(buf) 
2588          self.__field_unknown4.writetobuffer(buf) 
2589          self.__field_lg_time.writetobuffer(buf) 
2590          self.__field_GPStime.writetobuffer(buf) 
2591          self.__field_unknown5.writetobuffer(buf) 
2592          self.__field_read.writetobuffer(buf) 
2593          self.__field_locked.writetobuffer(buf) 
2594          self.__field_unknown8.writetobuffer(buf) 
2595          self.__field_priority.writetobuffer(buf) 
2596          self.__field_flags.writetobuffer(buf) 
2597          self.__field_subject.writetobuffer(buf) 
2598          self.__field_bin_header1.writetobuffer(buf) 
2599          self.__field_bin_header2.writetobuffer(buf) 
2600          self.__field_unknown6.writetobuffer(buf) 
2601          self.__field_multipartID.writetobuffer(buf) 
2602          self.__field_bin_header3.writetobuffer(buf) 
2603          self.__field_num_msg_elements.writetobuffer(buf) 
2604          try: self.__field_msglengths 
2605          except: 
2606              self.__field_msglengths=LIST(**{'elementclass': _gen_p_lgvx6000_249, 'length': 10}) 
2607          self.__field_msglengths.writetobuffer(buf) 
2608          try: self.__field_msgs 
2609          except: 
2610              self.__field_msgs=LIST(**{'length': 10, 'elementclass': SMSINBOXMSGFRAGMENT}) 
2611          self.__field_msgs.writetobuffer(buf) 
2612          self.__field_unknown5.writetobuffer(buf) 
2613          self.__field_senders_name.writetobuffer(buf) 
2614          self.__field_unknown6.writetobuffer(buf) 
2615          self._bufferendoffset=buf.getcurrentoffset() 
2616          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2617   
2618   
2619 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2620          'Reads this packet from the supplied buffer' 
2621          self._bufferstartoffset=buf.getcurrentoffset() 
2622          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2623          self.__field_msg_index1=UINT(**{'sizeinbytes': 4}) 
2624          self.__field_msg_index1.readfrombuffer(buf) 
2625          self.__field_msg_index2=UINT(**{'sizeinbytes': 4}) 
2626          self.__field_msg_index2.readfrombuffer(buf) 
2627          self.__field_unknown2=UINT(**{'sizeinbytes': 2}) 
2628          self.__field_unknown2.readfrombuffer(buf) 
2629          self.__field_unknown3=UINT(**{'sizeinbytes': 4}) 
2630          self.__field_unknown3.readfrombuffer(buf) 
2631          self.__field_timesent=SMSDATE(**{'sizeinbytes': 6}) 
2632          self.__field_timesent.readfrombuffer(buf) 
2633          self.__field_unknown=UINT(**{'sizeinbytes': 3}) 
2634          self.__field_unknown.readfrombuffer(buf) 
2635          self.__field_callback_length=UINT(**{'sizeinbytes': 1}) 
2636          self.__field_callback_length.readfrombuffer(buf) 
2637          self.__field_callback=USTRING(**{'sizeinbytes': 38}) 
2638          self.__field_callback.readfrombuffer(buf) 
2639          self.__field_sender_length=UINT(**{'sizeinbytes': 1}) 
2640          self.__field_sender_length.readfrombuffer(buf) 
2641          self.__field_sender=LIST(**{'elementclass': _gen_p_lgvx6000_231, 'length': 38}) 
2642          self.__field_sender.readfrombuffer(buf) 
2643          self.__field_unknown4=DATA(**{'sizeinbytes': 15}) 
2644          self.__field_unknown4.readfrombuffer(buf) 
2645          self.__field_lg_time=LGCALDATE(**{'sizeinbytes': 4}) 
2646          self.__field_lg_time.readfrombuffer(buf) 
2647          self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4}) 
2648          self.__field_GPStime.readfrombuffer(buf) 
2649          self.__field_unknown5=UINT(**{'sizeinbytes': 2}) 
2650          self.__field_unknown5.readfrombuffer(buf) 
2651          self.__field_read=UINT(**{'sizeinbytes': 1}) 
2652          self.__field_read.readfrombuffer(buf) 
2653          self.__field_locked=UINT(**{'sizeinbytes': 1}) 
2654          self.__field_locked.readfrombuffer(buf) 
2655          self.__field_unknown8=UINT(**{'sizeinbytes': 2}) 
2656          self.__field_unknown8.readfrombuffer(buf) 
2657          self.__field_priority=UINT(**{'sizeinbytes': 1}) 
2658          self.__field_priority.readfrombuffer(buf) 
2659          self.__field_flags=DATA(**{'sizeinbytes': 5}) 
2660          self.__field_flags.readfrombuffer(buf) 
2661          self.__field_subject=USTRING(**{'sizeinbytes': 21}) 
2662          self.__field_subject.readfrombuffer(buf) 
2663          self.__field_bin_header1=UINT(**{'sizeinbytes': 1}) 
2664          self.__field_bin_header1.readfrombuffer(buf) 
2665          self.__field_bin_header2=UINT(**{'sizeinbytes': 1}) 
2666          self.__field_bin_header2.readfrombuffer(buf) 
2667          self.__field_unknown6=UINT(**{'sizeinbytes': 2}) 
2668          self.__field_unknown6.readfrombuffer(buf) 
2669          self.__field_multipartID=UINT(**{'sizeinbytes': 2}) 
2670          self.__field_multipartID.readfrombuffer(buf) 
2671          self.__field_bin_header3=UINT(**{'sizeinbytes': 1}) 
2672          self.__field_bin_header3.readfrombuffer(buf) 
2673          self.__field_num_msg_elements=UINT(**{'sizeinbytes': 1}) 
2674          self.__field_num_msg_elements.readfrombuffer(buf) 
2675          self.__field_msglengths=LIST(**{'elementclass': _gen_p_lgvx6000_249, 'length': 10}) 
2676          self.__field_msglengths.readfrombuffer(buf) 
2677          self.__field_msgs=LIST(**{'length': 10, 'elementclass': SMSINBOXMSGFRAGMENT}) 
2678          self.__field_msgs.readfrombuffer(buf) 
2679          self.__field_unknown5=DATA(**{'sizeinbytes': 437}) 
2680          self.__field_unknown5.readfrombuffer(buf) 
2681          self.__field_senders_name=USTRING(**{'sizeinbytes': 33}) 
2682          self.__field_senders_name.readfrombuffer(buf) 
2683          self.__field_unknown6=DATA(**{'sizeinbytes': 169}) 
2684          self.__field_unknown6.readfrombuffer(buf) 
2685          self._bufferendoffset=buf.getcurrentoffset() 
2686   
2687   
2688 -    def __getfield_msg_index1(self): 
2689          return self.__field_msg_index1.getvalue() 
2690   
2691 -    def __setfield_msg_index1(self, value): 
2692          if isinstance(value,UINT): 
2693              self.__field_msg_index1=value 
2694          else: 
2695              self.__field_msg_index1=UINT(value,**{'sizeinbytes': 4}) 
2696   
2697 -    def __delfield_msg_index1(self): del self.__field_msg_index1 
2698   
2699      msg_index1=property(__getfield_msg_index1, __setfield_msg_index1, __delfield_msg_index1, None) 
2700   
2701 -    def __getfield_msg_index2(self): 
2702          return self.__field_msg_index2.getvalue() 
2703   
2704 -    def __setfield_msg_index2(self, value): 
2705          if isinstance(value,UINT): 
2706              self.__field_msg_index2=value 
2707          else: 
2708              self.__field_msg_index2=UINT(value,**{'sizeinbytes': 4}) 
2709   
2710 -    def __delfield_msg_index2(self): del self.__field_msg_index2 
2711   
2712      msg_index2=property(__getfield_msg_index2, __setfield_msg_index2, __delfield_msg_index2, None) 
2713   
2714 -    def __getfield_unknown2(self): 
2715          return self.__field_unknown2.getvalue() 
2716   
2717 -    def __setfield_unknown2(self, value): 
2718          if isinstance(value,UINT): 
2719              self.__field_unknown2=value 
2720          else: 
2721              self.__field_unknown2=UINT(value,**{'sizeinbytes': 2}) 
2722   
2723 -    def __delfield_unknown2(self): del self.__field_unknown2 
2724   
2725      unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None) 
2726   
2727 -    def __getfield_unknown3(self): 
2728          return self.__field_unknown3.getvalue() 
2729   
2730 -    def __setfield_unknown3(self, value): 
2731          if isinstance(value,UINT): 
2732              self.__field_unknown3=value 
2733          else: 
2734              self.__field_unknown3=UINT(value,**{'sizeinbytes': 4}) 
2735   
2736 -    def __delfield_unknown3(self): del self.__field_unknown3 
2737   
2738      unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None) 
2739   
2740 -    def __getfield_timesent(self): 
2741          return self.__field_timesent.getvalue() 
2742   
2743 -    def __setfield_timesent(self, value): 
2744          if isinstance(value,SMSDATE): 
2745              self.__field_timesent=value 
2746          else: 
2747              self.__field_timesent=SMSDATE(value,**{'sizeinbytes': 6}) 
2748   
2749 -    def __delfield_timesent(self): del self.__field_timesent 
2750   
2751      timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None) 
2752   
2753 -    def __getfield_unknown(self): 
2754          return self.__field_unknown.getvalue() 
2755   
2756 -    def __setfield_unknown(self, value): 
2757          if isinstance(value,UINT): 
2758              self.__field_unknown=value 
2759          else: 
2760              self.__field_unknown=UINT(value,**{'sizeinbytes': 3}) 
2761   
2762 -    def __delfield_unknown(self): del self.__field_unknown 
2763   
2764      unknown=property(__getfield_unknown, __setfield_unknown, __delfield_unknown, None) 
2765   
2766 -    def __getfield_callback_length(self): 
2767          return self.__field_callback_length.getvalue() 
2768   
2769 -    def __setfield_callback_length(self, value): 
2770          if isinstance(value,UINT): 
2771              self.__field_callback_length=value 
2772          else: 
2773              self.__field_callback_length=UINT(value,**{'sizeinbytes': 1}) 
2774   
2775 -    def __delfield_callback_length(self): del self.__field_callback_length 
2776   
2777      callback_length=property(__getfield_callback_length, __setfield_callback_length, __delfield_callback_length, None) 
2778   
2779 -    def __getfield_callback(self): 
2780          return self.__field_callback.getvalue() 
2781   
2782 -    def __setfield_callback(self, value): 
2783          if isinstance(value,USTRING): 
2784              self.__field_callback=value 
2785          else: 
2786              self.__field_callback=USTRING(value,**{'sizeinbytes': 38}) 
2787   
2788 -    def __delfield_callback(self): del self.__field_callback 
2789   
2790      callback=property(__getfield_callback, __setfield_callback, __delfield_callback, None) 
2791   
2792 -    def __getfield_sender_length(self): 
2793          return self.__field_sender_length.getvalue() 
2794   
2795 -    def __setfield_sender_length(self, value): 
2796          if isinstance(value,UINT): 
2797              self.__field_sender_length=value 
2798          else: 
2799              self.__field_sender_length=UINT(value,**{'sizeinbytes': 1}) 
2800   
2801 -    def __delfield_sender_length(self): del self.__field_sender_length 
2802   
2803      sender_length=property(__getfield_sender_length, __setfield_sender_length, __delfield_sender_length, None) 
2804   
2805 -    def __getfield_sender(self): 
2806          try: self.__field_sender 
2807          except: 
2808              self.__field_sender=LIST(**{'elementclass': _gen_p_lgvx6000_231, 'length': 38}) 
2809          return self.__field_sender.getvalue() 
2810   
2811 -    def __setfield_sender(self, value): 
2812          if isinstance(value,LIST): 
2813              self.__field_sender=value 
2814          else: 
2815              self.__field_sender=LIST(value,**{'elementclass': _gen_p_lgvx6000_231, 'length': 38}) 
2816   
2817 -    def __delfield_sender(self): del self.__field_sender 
2818   
2819      sender=property(__getfield_sender, __setfield_sender, __delfield_sender, None) 
2820   
2821 -    def __getfield_unknown4(self): 
2822          return self.__field_unknown4.getvalue() 
2823   
2824 -    def __setfield_unknown4(self, value): 
2825          if isinstance(value,DATA): 
2826              self.__field_unknown4=value 
2827          else: 
2828              self.__field_unknown4=DATA(value,**{'sizeinbytes': 15}) 
2829   
2830 -    def __delfield_unknown4(self): del self.__field_unknown4 
2831   
2832      unknown4=property(__getfield_unknown4, __setfield_unknown4, __delfield_unknown4, None) 
2833   
2834 -    def __getfield_lg_time(self): 
2835          return self.__field_lg_time.getvalue() 
2836   
2837 -    def __setfield_lg_time(self, value): 
2838          if isinstance(value,LGCALDATE): 
2839              self.__field_lg_time=value 
2840          else: 
2841              self.__field_lg_time=LGCALDATE(value,**{'sizeinbytes': 4}) 
2842   
2843 -    def __delfield_lg_time(self): del self.__field_lg_time 
2844   
2845      lg_time=property(__getfield_lg_time, __setfield_lg_time, __delfield_lg_time, None) 
2846   
2847 -    def __getfield_GPStime(self): 
2848          return self.__field_GPStime.getvalue() 
2849   
2850 -    def __setfield_GPStime(self, value): 
2851          if isinstance(value,GPSDATE): 
2852              self.__field_GPStime=value 
2853          else: 
2854              self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4}) 
2855   
2856 -    def __delfield_GPStime(self): del self.__field_GPStime 
2857   
2858      GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None) 
2859   
2860 -    def __getfield_unknown5(self): 
2861          return self.__field_unknown5.getvalue() 
2862   
2863 -    def __setfield_unknown5(self, value): 
2864          if isinstance(value,UINT): 
2865              self.__field_unknown5=value 
2866          else: 
2867              self.__field_unknown5=UINT(value,**{'sizeinbytes': 2}) 
2868   
2869 -    def __delfield_unknown5(self): del self.__field_unknown5 
2870   
2871      unknown5=property(__getfield_unknown5, __setfield_unknown5, __delfield_unknown5, None) 
2872   
2873 -    def __getfield_read(self): 
2874          return self.__field_read.getvalue() 
2875   
2876 -    def __setfield_read(self, value): 
2877          if isinstance(value,UINT): 
2878              self.__field_read=value 
2879          else: 
2880              self.__field_read=UINT(value,**{'sizeinbytes': 1}) 
2881   
2882 -    def __delfield_read(self): del self.__field_read 
2883   
2884      read=property(__getfield_read, __setfield_read, __delfield_read, None) 
2885   
2886 -    def __getfield_locked(self): 
2887          return self.__field_locked.getvalue() 
2888   
2889 -    def __setfield_locked(self, value): 
2890          if isinstance(value,UINT): 
2891              self.__field_locked=value 
2892          else: 
2893              self.__field_locked=UINT(value,**{'sizeinbytes': 1}) 
2894   
2895 -    def __delfield_locked(self): del self.__field_locked 
2896   
2897      locked=property(__getfield_locked, __setfield_locked, __delfield_locked, None) 
2898   
2899 -    def __getfield_unknown8(self): 
2900          return self.__field_unknown8.getvalue() 
2901   
2902 -    def __setfield_unknown8(self, value): 
2903          if isinstance(value,UINT): 
2904              self.__field_unknown8=value 
2905          else: 
2906              self.__field_unknown8=UINT(value,**{'sizeinbytes': 2}) 
2907   
2908 -    def __delfield_unknown8(self): del self.__field_unknown8 
2909   
2910      unknown8=property(__getfield_unknown8, __setfield_unknown8, __delfield_unknown8, None) 
2911   
2912 -    def __getfield_priority(self): 
2913          return self.__field_priority.getvalue() 
2914   
2915 -    def __setfield_priority(self, value): 
2916          if isinstance(value,UINT): 
2917              self.__field_priority=value 
2918          else: 
2919              self.__field_priority=UINT(value,**{'sizeinbytes': 1}) 
2920   
2921 -    def __delfield_priority(self): del self.__field_priority 
2922   
2923      priority=property(__getfield_priority, __setfield_priority, __delfield_priority, None) 
2924   
2925 -    def __getfield_flags(self): 
2926          return self.__field_flags.getvalue() 
2927   
2928 -    def __setfield_flags(self, value): 
2929          if isinstance(value,DATA): 
2930              self.__field_flags=value 
2931          else: 
2932              self.__field_flags=DATA(value,**{'sizeinbytes': 5}) 
2933   
2934 -    def __delfield_flags(self): del self.__field_flags 
2935   
2936      flags=property(__getfield_flags, __setfield_flags, __delfield_flags, None) 
2937   
2938 -    def __getfield_subject(self): 
2939          return self.__field_subject.getvalue() 
2940   
2941 -    def __setfield_subject(self, value): 
2942          if isinstance(value,USTRING): 
2943              self.__field_subject=value 
2944          else: 
2945              self.__field_subject=USTRING(value,**{'sizeinbytes': 21}) 
2946   
2947 -    def __delfield_subject(self): del self.__field_subject 
2948   
2949      subject=property(__getfield_subject, __setfield_subject, __delfield_subject, None) 
2950   
2951 -    def __getfield_bin_header1(self): 
2952          return self.__field_bin_header1.getvalue() 
2953   
2954 -    def __setfield_bin_header1(self, value): 
2955          if isinstance(value,UINT): 
2956              self.__field_bin_header1=value 
2957          else: 
2958              self.__field_bin_header1=UINT(value,**{'sizeinbytes': 1}) 
2959   
2960 -    def __delfield_bin_header1(self): del self.__field_bin_header1 
2961   
2962      bin_header1=property(__getfield_bin_header1, __setfield_bin_header1, __delfield_bin_header1, None) 
2963   
2964 -    def __getfield_bin_header2(self): 
2965          return self.__field_bin_header2.getvalue() 
2966   
2967 -    def __setfield_bin_header2(self, value): 
2968          if isinstance(value,UINT): 
2969              self.__field_bin_header2=value 
2970          else: 
2971              self.__field_bin_header2=UINT(value,**{'sizeinbytes': 1}) 
2972   
2973 -    def __delfield_bin_header2(self): del self.__field_bin_header2 
2974   
2975      bin_header2=property(__getfield_bin_header2, __setfield_bin_header2, __delfield_bin_header2, None) 
2976   
2977 -    def __getfield_unknown6(self): 
2978          return self.__field_unknown6.getvalue() 
2979   
2980 -    def __setfield_unknown6(self, value): 
2981          if isinstance(value,UINT): 
2982              self.__field_unknown6=value 
2983          else: 
2984              self.__field_unknown6=UINT(value,**{'sizeinbytes': 2}) 
2985   
2986 -    def __delfield_unknown6(self): del self.__field_unknown6 
2987   
2988      unknown6=property(__getfield_unknown6, __setfield_unknown6, __delfield_unknown6, None) 
2989   
2990 -    def __getfield_multipartID(self): 
2991          return self.__field_multipartID.getvalue() 
2992   
2993 -    def __setfield_multipartID(self, value): 
2994          if isinstance(value,UINT): 
2995              self.__field_multipartID=value 
2996          else: 
2997              self.__field_multipartID=UINT(value,**{'sizeinbytes': 2}) 
2998   
2999 -    def __delfield_multipartID(self): del self.__field_multipartID 
3000   
3001      multipartID=property(__getfield_multipartID, __setfield_multipartID, __delfield_multipartID, None) 
3002   
3003 -    def __getfield_bin_header3(self): 
3004          return self.__field_bin_header3.getvalue() 
3005   
3006 -    def __setfield_bin_header3(self, value): 
3007          if isinstance(value,UINT): 
3008              self.__field_bin_header3=value 
3009          else: 
3010              self.__field_bin_header3=UINT(value,**{'sizeinbytes': 1}) 
3011   
3012 -    def __delfield_bin_header3(self): del self.__field_bin_header3 
3013   
3014      bin_header3=property(__getfield_bin_header3, __setfield_bin_header3, __delfield_bin_header3, None) 
3015   
3016 -    def __getfield_num_msg_elements(self): 
3017          return self.__field_num_msg_elements.getvalue() 
3018   
3019 -    def __setfield_num_msg_elements(self, value): 
3020          if isinstance(value,UINT): 
3021              self.__field_num_msg_elements=value 
3022          else: 
3023              self.__field_num_msg_elements=UINT(value,**{'sizeinbytes': 1}) 
3024   
3025 -    def __delfield_num_msg_elements(self): del self.__field_num_msg_elements 
3026   
3027      num_msg_elements=property(__getfield_num_msg_elements, __setfield_num_msg_elements, __delfield_num_msg_elements, None) 
3028   
3029 -    def __getfield_msglengths(self): 
3030          try: self.__field_msglengths 
3031          except: 
3032              self.__field_msglengths=LIST(**{'elementclass': _gen_p_lgvx6000_249, 'length': 10}) 
3033          return self.__field_msglengths.getvalue() 
3034   
3035 -    def __setfield_msglengths(self, value): 
3036          if isinstance(value,LIST): 
3037              self.__field_msglengths=value 
3038          else: 
3039              self.__field_msglengths=LIST(value,**{'elementclass': _gen_p_lgvx6000_249, 'length': 10}) 
3040   
3041 -    def __delfield_msglengths(self): del self.__field_msglengths 
3042   
3043      msglengths=property(__getfield_msglengths, __setfield_msglengths, __delfield_msglengths, None) 
3044   
3045 -    def __getfield_msgs(self): 
3046          try: self.__field_msgs 
3047          except: 
3048              self.__field_msgs=LIST(**{'length': 10, 'elementclass': SMSINBOXMSGFRAGMENT}) 
3049          return self.__field_msgs.getvalue() 
3050   
3051 -    def __setfield_msgs(self, value): 
3052          if isinstance(value,LIST): 
3053              self.__field_msgs=value 
3054          else: 
3055              self.__field_msgs=LIST(value,**{'length': 10, 'elementclass': SMSINBOXMSGFRAGMENT}) 
3056   
3057 -    def __delfield_msgs(self): del self.__field_msgs 
3058   
3059      msgs=property(__getfield_msgs, __setfield_msgs, __delfield_msgs, None) 
3060   
3061 -    def __getfield_unknown5(self): 
3062          return self.__field_unknown5.getvalue() 
3063   
3064 -    def __setfield_unknown5(self, value): 
3065          if isinstance(value,DATA): 
3066              self.__field_unknown5=value 
3067          else: 
3068              self.__field_unknown5=DATA(value,**{'sizeinbytes': 437}) 
3069   
3070 -    def __delfield_unknown5(self): del self.__field_unknown5 
3071   
3072      unknown5=property(__getfield_unknown5, __setfield_unknown5, __delfield_unknown5, None) 
3073   
3074 -    def __getfield_senders_name(self): 
3075          return self.__field_senders_name.getvalue() 
3076   
3077 -    def __setfield_senders_name(self, value): 
3078          if isinstance(value,USTRING): 
3079              self.__field_senders_name=value 
3080          else: 
3081              self.__field_senders_name=USTRING(value,**{'sizeinbytes': 33}) 
3082   
3083 -    def __delfield_senders_name(self): del self.__field_senders_name 
3084   
3085      senders_name=property(__getfield_senders_name, __setfield_senders_name, __delfield_senders_name, None) 
3086   
3087 -    def __getfield_unknown6(self): 
3088          return self.__field_unknown6.getvalue() 
3089   
3090 -    def __setfield_unknown6(self, value): 
3091          if isinstance(value,DATA): 
3092              self.__field_unknown6=value 
3093          else: 
3094              self.__field_unknown6=DATA(value,**{'sizeinbytes': 169}) 
3095   
3096 -    def __delfield_unknown6(self): del self.__field_unknown6 
3097   
3098      unknown6=property(__getfield_unknown6, __setfield_unknown6, __delfield_unknown6, None) 
3099   
3100 -    def iscontainer(self): 
3101          return True 
3102   
3103 -    def containerelements(self): 
3104          yield ('msg_index1', self.__field_msg_index1, None) 
3105          yield ('msg_index2', self.__field_msg_index2, None) 
3106          yield ('unknown2', self.__field_unknown2, None) 
3107          yield ('unknown3', self.__field_unknown3, None) 
3108          yield ('timesent', self.__field_timesent, None) 
3109          yield ('unknown', self.__field_unknown, None) 
3110          yield ('callback_length', self.__field_callback_length, None) 
3111          yield ('callback', self.__field_callback, None) 
3112          yield ('sender_length', self.__field_sender_length, None) 
3113          yield ('sender', self.__field_sender, None) 
3114          yield ('unknown4', self.__field_unknown4, None) 
3115          yield ('lg_time', self.__field_lg_time, None) 
3116          yield ('GPStime', self.__field_GPStime, None) 
3117          yield ('unknown5', self.__field_unknown5, None) 
3118          yield ('read', self.__field_read, None) 
3119          yield ('locked', self.__field_locked, None) 
3120          yield ('unknown8', self.__field_unknown8, None) 
3121          yield ('priority', self.__field_priority, None) 
3122          yield ('flags', self.__field_flags, None) 
3123          yield ('subject', self.__field_subject, None) 
3124          yield ('bin_header1', self.__field_bin_header1, None) 
3125          yield ('bin_header2', self.__field_bin_header2, None) 
3126          yield ('unknown6', self.__field_unknown6, None) 
3127          yield ('multipartID', self.__field_multipartID, None) 
3128          yield ('bin_header3', self.__field_bin_header3, None) 
3129          yield ('num_msg_elements', self.__field_num_msg_elements, None) 
3130          yield ('msglengths', self.__field_msglengths, None) 
3131          yield ('msgs', self.__field_msgs, None) 
3132          yield ('unknown5', self.__field_unknown5, None) 
3133          yield ('senders_name', self.__field_senders_name, None) 
3134          yield ('unknown6', self.__field_unknown6, None) 
3135   
3136   
3137   
3138   
3139 -class _gen_p_lgvx6000_231(BaseProtogenClass): 
3140      'Anonymous inner class' 
3141      __fields=['byte'] 
3142   
3143 -    def __init__(self, *args, **kwargs): 
3144          dict={} 
3145          # What was supplied to this function 
3146          dict.update(kwargs) 
3147          # Parent constructor 
3148          super(_gen_p_lgvx6000_231,self).__init__(**dict) 
3149          if self.__class__ is _gen_p_lgvx6000_231: 
3150              self._update(args,dict) 
3151   
3152   
3153 -    def getfields(self): 
3154          return self.__fields 
3155   
3156   
3157 -    def _update(self, args, kwargs): 
3158          super(_gen_p_lgvx6000_231,self)._update(args,kwargs) 
3159          keys=kwargs.keys() 
3160          for key in keys: 
3161              if key in self.__fields: 
3162                  setattr(self, key, kwargs[key]) 
3163                  del kwargs[key] 
3164          # Were any unrecognized kwargs passed in? 
3165          if __debug__: 
3166              self._complainaboutunusedargs(_gen_p_lgvx6000_231,kwargs) 
3167          if len(args): 
3168              dict2={'sizeinbytes': 1} 
3169              dict2.update(kwargs) 
3170              kwargs=dict2 
3171              self.__field_byte=UINT(*args,**dict2) 
3172          # Make all P fields that haven't already been constructed 
3173   
3174   
3175 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3176          'Writes this packet to the supplied buffer' 
3177          self._bufferstartoffset=buf.getcurrentoffset() 
3178          self.__field_byte.writetobuffer(buf) 
3179          self._bufferendoffset=buf.getcurrentoffset() 
3180          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3181   
3182   
3183 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3184          'Reads this packet from the supplied buffer' 
3185          self._bufferstartoffset=buf.getcurrentoffset() 
3186          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3187          self.__field_byte=UINT(**{'sizeinbytes': 1}) 
3188          self.__field_byte.readfrombuffer(buf) 
3189          self._bufferendoffset=buf.getcurrentoffset() 
3190   
3191   
3192 -    def __getfield_byte(self): 
3193          return self.__field_byte.getvalue() 
3194   
3195 -    def __setfield_byte(self, value): 
3196          if isinstance(value,UINT): 
3197              self.__field_byte=value 
3198          else: 
3199              self.__field_byte=UINT(value,**{'sizeinbytes': 1}) 
3200   
3201 -    def __delfield_byte(self): del self.__field_byte 
3202   
3203      byte=property(__getfield_byte, __setfield_byte, __delfield_byte, "individual byte of senders phone number") 
3204   
3205 -    def iscontainer(self): 
3206          return True 
3207   
3208 -    def containerelements(self): 
3209          yield ('byte', self.__field_byte, "individual byte of senders phone number") 
3210   
3211   
3212   
3213   
3214 -class _gen_p_lgvx6000_249(BaseProtogenClass): 
3215      'Anonymous inner class' 
3216      __fields=['msglength'] 
3217   
3218 -    def __init__(self, *args, **kwargs): 
3219          dict={} 
3220          # What was supplied to this function 
3221          dict.update(kwargs) 
3222          # Parent constructor 
3223          super(_gen_p_lgvx6000_249,self).__init__(**dict) 
3224          if self.__class__ is _gen_p_lgvx6000_249: 
3225              self._update(args,dict) 
3226   
3227   
3228 -    def getfields(self): 
3229          return self.__fields 
3230   
3231   
3232 -    def _update(self, args, kwargs): 
3233          super(_gen_p_lgvx6000_249,self)._update(args,kwargs) 
3234          keys=kwargs.keys() 
3235          for key in keys: 
3236              if key in self.__fields: 
3237                  setattr(self, key, kwargs[key]) 
3238                  del kwargs[key] 
3239          # Were any unrecognized kwargs passed in? 
3240          if __debug__: 
3241              self._complainaboutunusedargs(_gen_p_lgvx6000_249,kwargs) 
3242          if len(args): 
3243              dict2={'sizeinbytes': 1} 
3244              dict2.update(kwargs) 
3245              kwargs=dict2 
3246              self.__field_msglength=UINT(*args,**dict2) 
3247          # Make all P fields that haven't already been constructed 
3248   
3249   
3250 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3251          'Writes this packet to the supplied buffer' 
3252          self._bufferstartoffset=buf.getcurrentoffset() 
3253          self.__field_msglength.writetobuffer(buf) 
3254          self._bufferendoffset=buf.getcurrentoffset() 
3255          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3256   
3257   
3258 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3259          'Reads this packet from the supplied buffer' 
3260          self._bufferstartoffset=buf.getcurrentoffset() 
3261          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3262          self.__field_msglength=UINT(**{'sizeinbytes': 1}) 
3263          self.__field_msglength.readfrombuffer(buf) 
3264          self._bufferendoffset=buf.getcurrentoffset() 
3265   
3266   
3267 -    def __getfield_msglength(self): 
3268          return self.__field_msglength.getvalue() 
3269   
3270 -    def __setfield_msglength(self, value): 
3271          if isinstance(value,UINT): 
3272              self.__field_msglength=value 
3273          else: 
3274              self.__field_msglength=UINT(value,**{'sizeinbytes': 1}) 
3275   
3276 -    def __delfield_msglength(self): del self.__field_msglength 
3277   
3278      msglength=property(__getfield_msglength, __setfield_msglength, __delfield_msglength, "lengths of individual messages in septets") 
3279   
3280 -    def iscontainer(self): 
3281          return True 
3282   
3283 -    def containerelements(self): 
3284          yield ('msglength', self.__field_msglength, "lengths of individual messages in septets") 
3285   
3286   
3287   
3288   
3289 -class sms_quick_text(BaseProtogenClass): 
3290      __fields=['msgs'] 
3291   
3292 -    def __init__(self, *args, **kwargs): 
3293          dict={} 
3294          # What was supplied to this function 
3295          dict.update(kwargs) 
3296          # Parent constructor 
3297          super(sms_quick_text,self).__init__(**dict) 
3298          if self.__class__ is sms_quick_text: 
3299              self._update(args,dict) 
3300   
3301   
3302 -    def getfields(self): 
3303          return self.__fields 
3304   
3305   
3306 -    def _update(self, args, kwargs): 
3307          super(sms_quick_text,self)._update(args,kwargs) 
3308          keys=kwargs.keys() 
3309          for key in keys: 
3310              if key in self.__fields: 
3311                  setattr(self, key, kwargs[key]) 
3312                  del kwargs[key] 
3313          # Were any unrecognized kwargs passed in? 
3314          if __debug__: 
3315              self._complainaboutunusedargs(sms_quick_text,kwargs) 
3316          if len(args): 
3317              dict2={'elementclass': _gen_p_lgvx6000_265, } 
3318              dict2.update(kwargs) 
3319              kwargs=dict2 
3320              self.__field_msgs=LIST(*args,**dict2) 
3321          # Make all P fields that haven't already been constructed 
3322   
3323   
3324 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3325          'Writes this packet to the supplied buffer' 
3326          self._bufferstartoffset=buf.getcurrentoffset() 
3327          try: self.__field_msgs 
3328          except: 
3329              self.__field_msgs=LIST(**{'elementclass': _gen_p_lgvx6000_265, }) 
3330          self.__field_msgs.writetobuffer(buf) 
3331          self._bufferendoffset=buf.getcurrentoffset() 
3332          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3333   
3334   
3335 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3336          'Reads this packet from the supplied buffer' 
3337          self._bufferstartoffset=buf.getcurrentoffset() 
3338          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3339          self.__field_msgs=LIST(**{'elementclass': _gen_p_lgvx6000_265, }) 
3340          self.__field_msgs.readfrombuffer(buf) 
3341          self._bufferendoffset=buf.getcurrentoffset() 
3342   
3343   
3344 -    def __getfield_msgs(self): 
3345          try: self.__field_msgs 
3346          except: 
3347              self.__field_msgs=LIST(**{'elementclass': _gen_p_lgvx6000_265, }) 
3348          return self.__field_msgs.getvalue() 
3349   
3350 -    def __setfield_msgs(self, value): 
3351          if isinstance(value,LIST): 
3352              self.__field_msgs=value 
3353          else: 
3354              self.__field_msgs=LIST(value,**{'elementclass': _gen_p_lgvx6000_265, }) 
3355   
3356 -    def __delfield_msgs(self): del self.__field_msgs 
3357   
3358      msgs=property(__getfield_msgs, __setfield_msgs, __delfield_msgs, None) 
3359   
3360 -    def iscontainer(self): 
3361          return True 
3362   
3363 -    def containerelements(self): 
3364          yield ('msgs', self.__field_msgs, None) 
3365   
3366   
3367   
3368   
3369 -class _gen_p_lgvx6000_265(BaseProtogenClass): 
3370      'Anonymous inner class' 
3371      __fields=['msg'] 
3372   
3373 -    def __init__(self, *args, **kwargs): 
3374          dict={} 
3375          # What was supplied to this function 
3376          dict.update(kwargs) 
3377          # Parent constructor 
3378          super(_gen_p_lgvx6000_265,self).__init__(**dict) 
3379          if self.__class__ is _gen_p_lgvx6000_265: 
3380              self._update(args,dict) 
3381   
3382   
3383 -    def getfields(self): 
3384          return self.__fields 
3385   
3386   
3387 -    def _update(self, args, kwargs): 
3388          super(_gen_p_lgvx6000_265,self)._update(args,kwargs) 
3389          keys=kwargs.keys() 
3390          for key in keys: 
3391              if key in self.__fields: 
3392                  setattr(self, key, kwargs[key]) 
3393                  del kwargs[key] 
3394          # Were any unrecognized kwargs passed in? 
3395          if __debug__: 
3396              self._complainaboutunusedargs(_gen_p_lgvx6000_265,kwargs) 
3397          if len(args): 
3398              dict2={} 
3399              dict2.update(kwargs) 
3400              kwargs=dict2 
3401              self.__field_msg=USTRING(*args,**dict2) 
3402          # Make all P fields that haven't already been constructed 
3403   
3404   
3405 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3406          'Writes this packet to the supplied buffer' 
3407          self._bufferstartoffset=buf.getcurrentoffset() 
3408          self.__field_msg.writetobuffer(buf) 
3409          self._bufferendoffset=buf.getcurrentoffset() 
3410          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3411   
3412   
3413 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3414          'Reads this packet from the supplied buffer' 
3415          self._bufferstartoffset=buf.getcurrentoffset() 
3416          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3417          self.__field_msg=USTRING(**{}) 
3418          self.__field_msg.readfrombuffer(buf) 
3419          self._bufferendoffset=buf.getcurrentoffset() 
3420   
3421   
3422 -    def __getfield_msg(self): 
3423          return self.__field_msg.getvalue() 
3424   
3425 -    def __setfield_msg(self, value): 
3426          if isinstance(value,USTRING): 
3427              self.__field_msg=value 
3428          else: 
3429              self.__field_msg=USTRING(value,**{}) 
3430   
3431 -    def __delfield_msg(self): del self.__field_msg 
3432   
3433      msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None) 
3434   
3435 -    def iscontainer(self): 
3436          return True 
3437   
3438 -    def containerelements(self): 
3439          yield ('msg', self.__field_msg, None) 
3440