Source Code for Module phones.p_lgvx6100

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