Source Code for Module phones.p_lglx5550

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