Source Code for Module phones.p_lglg8100

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