Source Code for Module phones.p_lglx5450

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