Source Code for Module phones.p_lgux5000

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