Source Code for Module phones.p_lgvx9100

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