Source Code for Module phones.p_lgvx4650

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