Source Code for Module phones.p_lgvx9800

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