Source Code for Module phones.p_lgvx4500

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