Source Code for Module phones.p_lgvx8550

   1  # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE 
   2   
   3  """Various descriptions of data specific to LG VX8550""" 
   4   
   5  from p_lgvx8700 import * 
   6  # same as the VX-8700 except as noted below 
   7   
   8  NUMPHONEBOOKENTRIES=1000 
   9  NUMPHONENUMBERENTRIES=5000 
  10   
  11  NUMSPEEDDIALS=100 
  12  FIRSTSPEEDDIAL=1 
  13  LASTSPEEDDIAL=99 
  14   
  15  NUMCALENDARENTRIES=300 
  16  NUMEMERGENCYCONTACTS=3 
  17   
  18  # sizes of pbfileentry and pnfileentry 
  19  PHONEBOOKENTRYSIZE=256 
  20  PHONENUMBERENTRYSIZE=64 
  21   
  22  NUM_EMAILS=2 
  23  NUMPHONENUMBERS=5 
  24   
  25  pb_file_name         = 'pim/pbentry.dat' 
  26  pb_recordid_filename = 'pim/record_id.dat' 
  27  pn_file_name         = 'pim/pbnumber.dat' 
  28  speed_file_name      = 'pim/pbspeed.dat' 
  29  ice_file_name        = 'pim/pbiceentry.dat' 
  30   
  31  PB_ENTRY_SOR='<PE>' 
  32  PB_NUMBER_SOR='<PN>' 
  33   
  34 -class speeddial(BaseProtogenClass): 
  35      __fields=['entry', 'number'] 
  36   
  37 -    def __init__(self, *args, **kwargs): 
  38          dict={} 
  39          # What was supplied to this function 
  40          dict.update(kwargs) 
  41          # Parent constructor 
  42          super(speeddial,self).__init__(**dict) 
  43          if self.__class__ is speeddial: 
  44              self._update(args,dict) 
  45   
  46   
  47 -    def getfields(self): 
  48          return self.__fields 
  49   
  50   
  51 -    def _update(self, args, kwargs): 
  52          super(speeddial,self)._update(args,kwargs) 
  53          keys=kwargs.keys() 
  54          for key in keys: 
  55              if key in self.__fields: 
  56                  setattr(self, key, kwargs[key]) 
  57                  del kwargs[key] 
  58          # Were any unrecognized kwargs passed in? 
  59          if __debug__: 
  60              self._complainaboutunusedargs(speeddial,kwargs) 
  61          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
  62          # Make all P fields that haven't already been constructed 
  63   
  64   
  65 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
  66          'Writes this packet to the supplied buffer' 
  67          self._bufferstartoffset=buf.getcurrentoffset() 
  68          try: self.__field_entry 
  69          except: 
  70              self.__field_entry=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
  71          self.__field_entry.writetobuffer(buf) 
  72          try: self.__field_number 
  73          except: 
  74              self.__field_number=UINT(**{'sizeinbytes': 1, 'default': 0xff}) 
  75          self.__field_number.writetobuffer(buf) 
  76          self._bufferendoffset=buf.getcurrentoffset() 
  77          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
  78   
  79   
  80 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
  81          'Reads this packet from the supplied buffer' 
  82          self._bufferstartoffset=buf.getcurrentoffset() 
  83          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
  84          self.__field_entry=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
  85          self.__field_entry.readfrombuffer(buf) 
  86          self.__field_number=UINT(**{'sizeinbytes': 1, 'default': 0xff}) 
  87          self.__field_number.readfrombuffer(buf) 
  88          self._bufferendoffset=buf.getcurrentoffset() 
  89   
  90   
  91 -    def __getfield_entry(self): 
  92          try: self.__field_entry 
  93          except: 
  94              self.__field_entry=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
  95          return self.__field_entry.getvalue() 
  96   
  97 -    def __setfield_entry(self, value): 
  98          if isinstance(value,UINT): 
  99              self.__field_entry=value 
 100          else: 
 101              self.__field_entry=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff}) 
 102   
 103 -    def __delfield_entry(self): del self.__field_entry 
 104   
 105      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, "0-based entry number") 
 106   
 107 -    def __getfield_number(self): 
 108          try: self.__field_number 
 109          except: 
 110              self.__field_number=UINT(**{'sizeinbytes': 1, 'default': 0xff}) 
 111          return self.__field_number.getvalue() 
 112   
 113 -    def __setfield_number(self, value): 
 114          if isinstance(value,UINT): 
 115              self.__field_number=value 
 116          else: 
 117              self.__field_number=UINT(value,**{'sizeinbytes': 1, 'default': 0xff}) 
 118   
 119 -    def __delfield_number(self): del self.__field_number 
 120   
 121      number=property(__getfield_number, __setfield_number, __delfield_number, "number type") 
 122   
 123 -    def iscontainer(self): 
 124          return True 
 125   
 126 -    def containerelements(self): 
 127          yield ('entry', self.__field_entry, "0-based entry number") 
 128          yield ('number', self.__field_number, "number type") 
 129   
 130 -    def valid(self): 
 131          return self.entry!=0xffff 
 132   
 133   
 134   
 135   
 136 -class speeddials(BaseProtogenClass): 
 137      __fields=['speeddials'] 
 138   
 139 -    def __init__(self, *args, **kwargs): 
 140          dict={} 
 141          # What was supplied to this function 
 142          dict.update(kwargs) 
 143          # Parent constructor 
 144          super(speeddials,self).__init__(**dict) 
 145          if self.__class__ is speeddials: 
 146              self._update(args,dict) 
 147   
 148   
 149 -    def getfields(self): 
 150          return self.__fields 
 151   
 152   
 153 -    def _update(self, args, kwargs): 
 154          super(speeddials,self)._update(args,kwargs) 
 155          keys=kwargs.keys() 
 156          for key in keys: 
 157              if key in self.__fields: 
 158                  setattr(self, key, kwargs[key]) 
 159                  del kwargs[key] 
 160          # Were any unrecognized kwargs passed in? 
 161          if __debug__: 
 162              self._complainaboutunusedargs(speeddials,kwargs) 
 163          if len(args): 
 164              dict2={'length': NUMSPEEDDIALS, 'elementclass': speeddial} 
 165              dict2.update(kwargs) 
 166              kwargs=dict2 
 167              self.__field_speeddials=LIST(*args,**dict2) 
 168          # Make all P fields that haven't already been constructed 
 169   
 170   
 171 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 172          'Writes this packet to the supplied buffer' 
 173          self._bufferstartoffset=buf.getcurrentoffset() 
 174          try: self.__field_speeddials 
 175          except: 
 176              self.__field_speeddials=LIST(**{'length': NUMSPEEDDIALS, 'elementclass': speeddial}) 
 177          self.__field_speeddials.writetobuffer(buf) 
 178          self._bufferendoffset=buf.getcurrentoffset() 
 179          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 180   
 181   
 182 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 183          'Reads this packet from the supplied buffer' 
 184          self._bufferstartoffset=buf.getcurrentoffset() 
 185          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 186          self.__field_speeddials=LIST(**{'length': NUMSPEEDDIALS, 'elementclass': speeddial}) 
 187          self.__field_speeddials.readfrombuffer(buf) 
 188          self._bufferendoffset=buf.getcurrentoffset() 
 189   
 190   
 191 -    def __getfield_speeddials(self): 
 192          try: self.__field_speeddials 
 193          except: 
 194              self.__field_speeddials=LIST(**{'length': NUMSPEEDDIALS, 'elementclass': speeddial}) 
 195          return self.__field_speeddials.getvalue() 
 196   
 197 -    def __setfield_speeddials(self, value): 
 198          if isinstance(value,LIST): 
 199              self.__field_speeddials=value 
 200          else: 
 201              self.__field_speeddials=LIST(value,**{'length': NUMSPEEDDIALS, 'elementclass': speeddial}) 
 202   
 203 -    def __delfield_speeddials(self): del self.__field_speeddials 
 204   
 205      speeddials=property(__getfield_speeddials, __setfield_speeddials, __delfield_speeddials, None) 
 206   
 207 -    def iscontainer(self): 
 208          return True 
 209   
 210 -    def containerelements(self): 
 211          yield ('speeddials', self.__field_speeddials, None) 
 212   
 213   
 214   
 215   
 216 -class pbfileentry(BaseProtogenClass): 
 217      __fields=['entry_tag', 'mod_date', 'unk0', 'entry_number1', 'entry_number0', 'name', 'group', 'emails', 'ringtone', 'wallpaper', 'numbertypes', 'numberindices', 'memo', 'exit_tag', 'dontcare'] 
 218   
 219 -    def __init__(self, *args, **kwargs): 
 220          dict={} 
 221          # What was supplied to this function 
 222          dict.update(kwargs) 
 223          # Parent constructor 
 224          super(pbfileentry,self).__init__(**dict) 
 225          if self.__class__ is pbfileentry: 
 226              self._update(args,dict) 
 227   
 228   
 229 -    def getfields(self): 
 230          return self.__fields 
 231   
 232   
 233 -    def _update(self, args, kwargs): 
 234          super(pbfileentry,self)._update(args,kwargs) 
 235          keys=kwargs.keys() 
 236          for key in keys: 
 237              if key in self.__fields: 
 238                  setattr(self, key, kwargs[key]) 
 239                  del kwargs[key] 
 240          # Were any unrecognized kwargs passed in? 
 241          if __debug__: 
 242              self._complainaboutunusedargs(pbfileentry,kwargs) 
 243          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 244          # Make all P fields that haven't already been constructed 
 245   
 246   
 247 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 248          'Writes this packet to the supplied buffer' 
 249          self._bufferstartoffset=buf.getcurrentoffset() 
 250          try: self.__field_entry_tag 
 251          except: 
 252              self.__field_entry_tag=STRING(**{'sizeinbytes': 5,  'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '\xff\xff\xff\xff\xff' }) 
 253          self.__field_entry_tag.writetobuffer(buf) 
 254          if self.entry_tag==PB_ENTRY_SOR: 
 255              try: self.__field_mod_date 
 256              except: 
 257                  self.__field_mod_date=PBDateTime(**{ 'defaulttocurrenttime': True }) 
 258              self.__field_mod_date.writetobuffer(buf) 
 259              try: self.__field_unk0 
 260              except: 
 261                  self.__field_unk0=STRING(**{'sizeinbytes': 6,  'terminator': None, 'default': '\xff\xff\xff\xff\xff\xff' }) 
 262              self.__field_unk0.writetobuffer(buf) 
 263              self.__field_entry_number1.writetobuffer(buf) 
 264              self.__field_entry_number0.writetobuffer(buf) 
 265              try: self.__field_name 
 266              except: 
 267                  self.__field_name=USTRING(**{'sizeinbytes': 33,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False }) 
 268              self.__field_name.writetobuffer(buf) 
 269              try: self.__field_group 
 270              except: 
 271                  self.__field_group=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
 272              self.__field_group.writetobuffer(buf) 
 273              try: self.__field_emails 
 274              except: 
 275                  self.__field_emails=LIST(**{'elementclass': _gen_p_lgvx8550_72, 'length': NUMEMAILS}) 
 276              self.__field_emails.writetobuffer(buf) 
 277              try: self.__field_ringtone 
 278              except: 
 279                  self.__field_ringtone=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
 280              self.__field_ringtone.writetobuffer(buf) 
 281              try: self.__field_wallpaper 
 282              except: 
 283                  self.__field_wallpaper=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
 284              self.__field_wallpaper.writetobuffer(buf) 
 285              try: self.__field_numbertypes 
 286              except: 
 287                  self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lgvx8550_76, 'length': NUMPHONENUMBERS}) 
 288              self.__field_numbertypes.writetobuffer(buf) 
 289              try: self.__field_numberindices 
 290              except: 
 291                  self.__field_numberindices=LIST(**{'elementclass': _gen_p_lgvx8550_78, 'length': NUMPHONENUMBERS}) 
 292              self.__field_numberindices.writetobuffer(buf) 
 293              try: self.__field_memo 
 294              except: 
 295                  self.__field_memo=USTRING(**{'sizeinbytes': 69,  'raiseonunterminatedread': False, 'default': '', 'encoding': PHONE_ENCODING }) 
 296              self.__field_memo.writetobuffer(buf) 
 297              try: self.__field_exit_tag 
 298              except: 
 299                  self.__field_exit_tag=USTRING(**{'sizeinbytes': 6,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '</PE>'}) 
 300              self.__field_exit_tag.writetobuffer(buf) 
 301          else: 
 302              try: self.__field_dontcare 
 303              except: 
 304                  self.__field_dontcare=DATA(**{'sizeinbytes': 251,  'default': '\xff'*251 }) 
 305              self.__field_dontcare.writetobuffer(buf) 
 306          self._bufferendoffset=buf.getcurrentoffset() 
 307          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 308   
 309   
 310 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 311          'Reads this packet from the supplied buffer' 
 312          self._bufferstartoffset=buf.getcurrentoffset() 
 313          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 314          self.__field_entry_tag=STRING(**{'sizeinbytes': 5,  'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '\xff\xff\xff\xff\xff' }) 
 315          self.__field_entry_tag.readfrombuffer(buf) 
 316          if self.entry_tag==PB_ENTRY_SOR: 
 317              self.__field_mod_date=PBDateTime(**{ 'defaulttocurrenttime': True }) 
 318              self.__field_mod_date.readfrombuffer(buf) 
 319              self.__field_unk0=STRING(**{'sizeinbytes': 6,  'terminator': None, 'default': '\xff\xff\xff\xff\xff\xff' }) 
 320              self.__field_unk0.readfrombuffer(buf) 
 321              self.__field_entry_number1=UINT(**{'sizeinbytes': 4}) 
 322              self.__field_entry_number1.readfrombuffer(buf) 
 323              self.__field_entry_number0=UINT(**{'sizeinbytes': 2}) 
 324              self.__field_entry_number0.readfrombuffer(buf) 
 325              self.__field_name=USTRING(**{'sizeinbytes': 33,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False }) 
 326              self.__field_name.readfrombuffer(buf) 
 327              self.__field_group=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
 328              self.__field_group.readfrombuffer(buf) 
 329              self.__field_emails=LIST(**{'elementclass': _gen_p_lgvx8550_72, 'length': NUMEMAILS}) 
 330              self.__field_emails.readfrombuffer(buf) 
 331              self.__field_ringtone=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
 332              self.__field_ringtone.readfrombuffer(buf) 
 333              self.__field_wallpaper=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
 334              self.__field_wallpaper.readfrombuffer(buf) 
 335              self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lgvx8550_76, 'length': NUMPHONENUMBERS}) 
 336              self.__field_numbertypes.readfrombuffer(buf) 
 337              self.__field_numberindices=LIST(**{'elementclass': _gen_p_lgvx8550_78, 'length': NUMPHONENUMBERS}) 
 338              self.__field_numberindices.readfrombuffer(buf) 
 339              self.__field_memo=USTRING(**{'sizeinbytes': 69,  'raiseonunterminatedread': False, 'default': '', 'encoding': PHONE_ENCODING }) 
 340              self.__field_memo.readfrombuffer(buf) 
 341              self.__field_exit_tag=USTRING(**{'sizeinbytes': 6,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '</PE>'}) 
 342              self.__field_exit_tag.readfrombuffer(buf) 
 343          else: 
 344              self.__field_dontcare=DATA(**{'sizeinbytes': 251,  'default': '\xff'*251 }) 
 345              self.__field_dontcare.readfrombuffer(buf) 
 346          self._bufferendoffset=buf.getcurrentoffset() 
 347   
 348   
 349 -    def __getfield_entry_tag(self): 
 350          try: self.__field_entry_tag 
 351          except: 
 352              self.__field_entry_tag=STRING(**{'sizeinbytes': 5,  'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '\xff\xff\xff\xff\xff' }) 
 353          return self.__field_entry_tag.getvalue() 
 354   
 355 -    def __setfield_entry_tag(self, value): 
 356          if isinstance(value,STRING): 
 357              self.__field_entry_tag=value 
 358          else: 
 359              self.__field_entry_tag=STRING(value,**{'sizeinbytes': 5,  'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '\xff\xff\xff\xff\xff' }) 
 360   
 361 -    def __delfield_entry_tag(self): del self.__field_entry_tag 
 362   
 363      entry_tag=property(__getfield_entry_tag, __setfield_entry_tag, __delfield_entry_tag, None) 
 364   
 365 -    def __getfield_mod_date(self): 
 366          try: self.__field_mod_date 
 367          except: 
 368              self.__field_mod_date=PBDateTime(**{ 'defaulttocurrenttime': True }) 
 369          return self.__field_mod_date.getvalue() 
 370   
 371 -    def __setfield_mod_date(self, value): 
 372          if isinstance(value,PBDateTime): 
 373              self.__field_mod_date=value 
 374          else: 
 375              self.__field_mod_date=PBDateTime(value,**{ 'defaulttocurrenttime': True }) 
 376   
 377 -    def __delfield_mod_date(self): del self.__field_mod_date 
 378   
 379      mod_date=property(__getfield_mod_date, __setfield_mod_date, __delfield_mod_date, None) 
 380   
 381 -    def __getfield_unk0(self): 
 382          try: self.__field_unk0 
 383          except: 
 384              self.__field_unk0=STRING(**{'sizeinbytes': 6,  'terminator': None, 'default': '\xff\xff\xff\xff\xff\xff' }) 
 385          return self.__field_unk0.getvalue() 
 386   
 387 -    def __setfield_unk0(self, value): 
 388          if isinstance(value,STRING): 
 389              self.__field_unk0=value 
 390          else: 
 391              self.__field_unk0=STRING(value,**{'sizeinbytes': 6,  'terminator': None, 'default': '\xff\xff\xff\xff\xff\xff' }) 
 392   
 393 -    def __delfield_unk0(self): del self.__field_unk0 
 394   
 395      unk0=property(__getfield_unk0, __setfield_unk0, __delfield_unk0, None) 
 396   
 397 -    def __getfield_entry_number1(self): 
 398          return self.__field_entry_number1.getvalue() 
 399   
 400 -    def __setfield_entry_number1(self, value): 
 401          if isinstance(value,UINT): 
 402              self.__field_entry_number1=value 
 403          else: 
 404              self.__field_entry_number1=UINT(value,**{'sizeinbytes': 4}) 
 405   
 406 -    def __delfield_entry_number1(self): del self.__field_entry_number1 
 407   
 408      entry_number1=property(__getfield_entry_number1, __setfield_entry_number1, __delfield_entry_number1, None) 
 409   
 410 -    def __getfield_entry_number0(self): 
 411          return self.__field_entry_number0.getvalue() 
 412   
 413 -    def __setfield_entry_number0(self, value): 
 414          if isinstance(value,UINT): 
 415              self.__field_entry_number0=value 
 416          else: 
 417              self.__field_entry_number0=UINT(value,**{'sizeinbytes': 2}) 
 418   
 419 -    def __delfield_entry_number0(self): del self.__field_entry_number0 
 420   
 421      entry_number0=property(__getfield_entry_number0, __setfield_entry_number0, __delfield_entry_number0, None) 
 422   
 423 -    def __getfield_name(self): 
 424          try: self.__field_name 
 425          except: 
 426              self.__field_name=USTRING(**{'sizeinbytes': 33,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False }) 
 427          return self.__field_name.getvalue() 
 428   
 429 -    def __setfield_name(self, value): 
 430          if isinstance(value,USTRING): 
 431              self.__field_name=value 
 432          else: 
 433              self.__field_name=USTRING(value,**{'sizeinbytes': 33,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False }) 
 434   
 435 -    def __delfield_name(self): del self.__field_name 
 436   
 437      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
 438   
 439 -    def __getfield_group(self): 
 440          try: self.__field_group 
 441          except: 
 442              self.__field_group=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
 443          return self.__field_group.getvalue() 
 444   
 445 -    def __setfield_group(self, value): 
 446          if isinstance(value,UINT): 
 447              self.__field_group=value 
 448          else: 
 449              self.__field_group=UINT(value,**{'sizeinbytes': 2,  'default': 0 }) 
 450   
 451 -    def __delfield_group(self): del self.__field_group 
 452   
 453      group=property(__getfield_group, __setfield_group, __delfield_group, None) 
 454   
 455 -    def __getfield_emails(self): 
 456          try: self.__field_emails 
 457          except: 
 458              self.__field_emails=LIST(**{'elementclass': _gen_p_lgvx8550_72, 'length': NUMEMAILS}) 
 459          return self.__field_emails.getvalue() 
 460   
 461 -    def __setfield_emails(self, value): 
 462          if isinstance(value,LIST): 
 463              self.__field_emails=value 
 464          else: 
 465              self.__field_emails=LIST(value,**{'elementclass': _gen_p_lgvx8550_72, 'length': NUMEMAILS}) 
 466   
 467 -    def __delfield_emails(self): del self.__field_emails 
 468   
 469      emails=property(__getfield_emails, __setfield_emails, __delfield_emails, None) 
 470   
 471 -    def __getfield_ringtone(self): 
 472          try: self.__field_ringtone 
 473          except: 
 474              self.__field_ringtone=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
 475          return self.__field_ringtone.getvalue() 
 476   
 477 -    def __setfield_ringtone(self, value): 
 478          if isinstance(value,UINT): 
 479              self.__field_ringtone=value 
 480          else: 
 481              self.__field_ringtone=UINT(value,**{'sizeinbytes': 2,  'default': 0xffff }) 
 482   
 483 -    def __delfield_ringtone(self): del self.__field_ringtone 
 484   
 485      ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 
 486   
 487 -    def __getfield_wallpaper(self): 
 488          try: self.__field_wallpaper 
 489          except: 
 490              self.__field_wallpaper=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
 491          return self.__field_wallpaper.getvalue() 
 492   
 493 -    def __setfield_wallpaper(self, value): 
 494          if isinstance(value,UINT): 
 495              self.__field_wallpaper=value 
 496          else: 
 497              self.__field_wallpaper=UINT(value,**{'sizeinbytes': 2,  'default': 0 }) 
 498   
 499 -    def __delfield_wallpaper(self): del self.__field_wallpaper 
 500   
 501      wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None) 
 502   
 503 -    def __getfield_numbertypes(self): 
 504          try: self.__field_numbertypes 
 505          except: 
 506              self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lgvx8550_76, 'length': NUMPHONENUMBERS}) 
 507          return self.__field_numbertypes.getvalue() 
 508   
 509 -    def __setfield_numbertypes(self, value): 
 510          if isinstance(value,LIST): 
 511              self.__field_numbertypes=value 
 512          else: 
 513              self.__field_numbertypes=LIST(value,**{'elementclass': _gen_p_lgvx8550_76, 'length': NUMPHONENUMBERS}) 
 514   
 515 -    def __delfield_numbertypes(self): del self.__field_numbertypes 
 516   
 517      numbertypes=property(__getfield_numbertypes, __setfield_numbertypes, __delfield_numbertypes, None) 
 518   
 519 -    def __getfield_numberindices(self): 
 520          try: self.__field_numberindices 
 521          except: 
 522              self.__field_numberindices=LIST(**{'elementclass': _gen_p_lgvx8550_78, 'length': NUMPHONENUMBERS}) 
 523          return self.__field_numberindices.getvalue() 
 524   
 525 -    def __setfield_numberindices(self, value): 
 526          if isinstance(value,LIST): 
 527              self.__field_numberindices=value 
 528          else: 
 529              self.__field_numberindices=LIST(value,**{'elementclass': _gen_p_lgvx8550_78, 'length': NUMPHONENUMBERS}) 
 530   
 531 -    def __delfield_numberindices(self): del self.__field_numberindices 
 532   
 533      numberindices=property(__getfield_numberindices, __setfield_numberindices, __delfield_numberindices, None) 
 534   
 535 -    def __getfield_memo(self): 
 536          try: self.__field_memo 
 537          except: 
 538              self.__field_memo=USTRING(**{'sizeinbytes': 69,  'raiseonunterminatedread': False, 'default': '', 'encoding': PHONE_ENCODING }) 
 539          return self.__field_memo.getvalue() 
 540   
 541 -    def __setfield_memo(self, value): 
 542          if isinstance(value,USTRING): 
 543              self.__field_memo=value 
 544          else: 
 545              self.__field_memo=USTRING(value,**{'sizeinbytes': 69,  'raiseonunterminatedread': False, 'default': '', 'encoding': PHONE_ENCODING }) 
 546   
 547 -    def __delfield_memo(self): del self.__field_memo 
 548   
 549      memo=property(__getfield_memo, __setfield_memo, __delfield_memo, None) 
 550   
 551 -    def __getfield_exit_tag(self): 
 552          try: self.__field_exit_tag 
 553          except: 
 554              self.__field_exit_tag=USTRING(**{'sizeinbytes': 6,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '</PE>'}) 
 555          return self.__field_exit_tag.getvalue() 
 556   
 557 -    def __setfield_exit_tag(self, value): 
 558          if isinstance(value,USTRING): 
 559              self.__field_exit_tag=value 
 560          else: 
 561              self.__field_exit_tag=USTRING(value,**{'sizeinbytes': 6,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '</PE>'}) 
 562   
 563 -    def __delfield_exit_tag(self): del self.__field_exit_tag 
 564   
 565      exit_tag=property(__getfield_exit_tag, __setfield_exit_tag, __delfield_exit_tag, None) 
 566   
 567 -    def __getfield_dontcare(self): 
 568          try: self.__field_dontcare 
 569          except: 
 570              self.__field_dontcare=DATA(**{'sizeinbytes': 251,  'default': '\xff'*251 }) 
 571          return self.__field_dontcare.getvalue() 
 572   
 573 -    def __setfield_dontcare(self, value): 
 574          if isinstance(value,DATA): 
 575              self.__field_dontcare=value 
 576          else: 
 577              self.__field_dontcare=DATA(value,**{'sizeinbytes': 251,  'default': '\xff'*251 }) 
 578   
 579 -    def __delfield_dontcare(self): del self.__field_dontcare 
 580   
 581      dontcare=property(__getfield_dontcare, __setfield_dontcare, __delfield_dontcare, None) 
 582   
 583 -    def iscontainer(self): 
 584          return True 
 585   
 586 -    def containerelements(self): 
 587          yield ('entry_tag', self.__field_entry_tag, None) 
 588          if self.entry_tag==PB_ENTRY_SOR: 
 589              yield ('mod_date', self.__field_mod_date, None) 
 590              yield ('unk0', self.__field_unk0, None) 
 591              yield ('entry_number1', self.__field_entry_number1, None) 
 592              yield ('entry_number0', self.__field_entry_number0, None) 
 593              yield ('name', self.__field_name, None) 
 594              yield ('group', self.__field_group, None) 
 595              yield ('emails', self.__field_emails, None) 
 596              yield ('ringtone', self.__field_ringtone, None) 
 597              yield ('wallpaper', self.__field_wallpaper, None) 
 598              yield ('numbertypes', self.__field_numbertypes, None) 
 599              yield ('numberindices', self.__field_numberindices, None) 
 600              yield ('memo', self.__field_memo, None) 
 601              yield ('exit_tag', self.__field_exit_tag, None) 
 602          else: 
 603              yield ('dontcare', self.__field_dontcare, None) 
 604   
 605 -    def valid(self): 
 606          global PB_ENTRY_SOR 
 607          return self.entry_tag==PB_ENTRY_SOR and ord(self.name[0]) != 0xff 
 608   
 609   
 610   
 611   
 612 -class _gen_p_lgvx8550_72(BaseProtogenClass): 
 613      'Anonymous inner class' 
 614      __fields=['email'] 
 615   
 616 -    def __init__(self, *args, **kwargs): 
 617          dict={} 
 618          # What was supplied to this function 
 619          dict.update(kwargs) 
 620          # Parent constructor 
 621          super(_gen_p_lgvx8550_72,self).__init__(**dict) 
 622          if self.__class__ is _gen_p_lgvx8550_72: 
 623              self._update(args,dict) 
 624   
 625   
 626 -    def getfields(self): 
 627          return self.__fields 
 628   
 629   
 630 -    def _update(self, args, kwargs): 
 631          super(_gen_p_lgvx8550_72,self)._update(args,kwargs) 
 632          keys=kwargs.keys() 
 633          for key in keys: 
 634              if key in self.__fields: 
 635                  setattr(self, key, kwargs[key]) 
 636                  del kwargs[key] 
 637          # Were any unrecognized kwargs passed in? 
 638          if __debug__: 
 639              self._complainaboutunusedargs(_gen_p_lgvx8550_72,kwargs) 
 640          if len(args): 
 641              dict2={'sizeinbytes': 49, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False} 
 642              dict2.update(kwargs) 
 643              kwargs=dict2 
 644              self.__field_email=USTRING(*args,**dict2) 
 645          # Make all P fields that haven't already been constructed 
 646   
 647   
 648 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 649          'Writes this packet to the supplied buffer' 
 650          self._bufferstartoffset=buf.getcurrentoffset() 
 651          self.__field_email.writetobuffer(buf) 
 652          self._bufferendoffset=buf.getcurrentoffset() 
 653          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 654   
 655   
 656 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 657          'Reads this packet from the supplied buffer' 
 658          self._bufferstartoffset=buf.getcurrentoffset() 
 659          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 660          self.__field_email=USTRING(**{'sizeinbytes': 49, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
 661          self.__field_email.readfrombuffer(buf) 
 662          self._bufferendoffset=buf.getcurrentoffset() 
 663   
 664   
 665 -    def __getfield_email(self): 
 666          return self.__field_email.getvalue() 
 667   
 668 -    def __setfield_email(self, value): 
 669          if isinstance(value,USTRING): 
 670              self.__field_email=value 
 671          else: 
 672              self.__field_email=USTRING(value,**{'sizeinbytes': 49, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
 673   
 674 -    def __delfield_email(self): del self.__field_email 
 675   
 676      email=property(__getfield_email, __setfield_email, __delfield_email, None) 
 677   
 678 -    def iscontainer(self): 
 679          return True 
 680   
 681 -    def containerelements(self): 
 682          yield ('email', self.__field_email, None) 
 683   
 684   
 685   
 686   
 687 -class _gen_p_lgvx8550_76(BaseProtogenClass): 
 688      'Anonymous inner class' 
 689      __fields=['numbertype'] 
 690   
 691 -    def __init__(self, *args, **kwargs): 
 692          dict={} 
 693          # What was supplied to this function 
 694          dict.update(kwargs) 
 695          # Parent constructor 
 696          super(_gen_p_lgvx8550_76,self).__init__(**dict) 
 697          if self.__class__ is _gen_p_lgvx8550_76: 
 698              self._update(args,dict) 
 699   
 700   
 701 -    def getfields(self): 
 702          return self.__fields 
 703   
 704   
 705 -    def _update(self, args, kwargs): 
 706          super(_gen_p_lgvx8550_76,self)._update(args,kwargs) 
 707          keys=kwargs.keys() 
 708          for key in keys: 
 709              if key in self.__fields: 
 710                  setattr(self, key, kwargs[key]) 
 711                  del kwargs[key] 
 712          # Were any unrecognized kwargs passed in? 
 713          if __debug__: 
 714              self._complainaboutunusedargs(_gen_p_lgvx8550_76,kwargs) 
 715          if len(args): 
 716              dict2={'sizeinbytes': 1,  'default': 0 } 
 717              dict2.update(kwargs) 
 718              kwargs=dict2 
 719              self.__field_numbertype=UINT(*args,**dict2) 
 720          # Make all P fields that haven't already been constructed 
 721   
 722   
 723 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 724          'Writes this packet to the supplied buffer' 
 725          self._bufferstartoffset=buf.getcurrentoffset() 
 726          self.__field_numbertype.writetobuffer(buf) 
 727          self._bufferendoffset=buf.getcurrentoffset() 
 728          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 729   
 730   
 731 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 732          'Reads this packet from the supplied buffer' 
 733          self._bufferstartoffset=buf.getcurrentoffset() 
 734          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 735          self.__field_numbertype=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
 736          self.__field_numbertype.readfrombuffer(buf) 
 737          self._bufferendoffset=buf.getcurrentoffset() 
 738   
 739   
 740 -    def __getfield_numbertype(self): 
 741          return self.__field_numbertype.getvalue() 
 742   
 743 -    def __setfield_numbertype(self, value): 
 744          if isinstance(value,UINT): 
 745              self.__field_numbertype=value 
 746          else: 
 747              self.__field_numbertype=UINT(value,**{'sizeinbytes': 1,  'default': 0 }) 
 748   
 749 -    def __delfield_numbertype(self): del self.__field_numbertype 
 750   
 751      numbertype=property(__getfield_numbertype, __setfield_numbertype, __delfield_numbertype, None) 
 752   
 753 -    def iscontainer(self): 
 754          return True 
 755   
 756 -    def containerelements(self): 
 757          yield ('numbertype', self.__field_numbertype, None) 
 758   
 759   
 760   
 761   
 762 -class _gen_p_lgvx8550_78(BaseProtogenClass): 
 763      'Anonymous inner class' 
 764      __fields=['numberindex'] 
 765   
 766 -    def __init__(self, *args, **kwargs): 
 767          dict={} 
 768          # What was supplied to this function 
 769          dict.update(kwargs) 
 770          # Parent constructor 
 771          super(_gen_p_lgvx8550_78,self).__init__(**dict) 
 772          if self.__class__ is _gen_p_lgvx8550_78: 
 773              self._update(args,dict) 
 774   
 775   
 776 -    def getfields(self): 
 777          return self.__fields 
 778   
 779   
 780 -    def _update(self, args, kwargs): 
 781          super(_gen_p_lgvx8550_78,self)._update(args,kwargs) 
 782          keys=kwargs.keys() 
 783          for key in keys: 
 784              if key in self.__fields: 
 785                  setattr(self, key, kwargs[key]) 
 786                  del kwargs[key] 
 787          # Were any unrecognized kwargs passed in? 
 788          if __debug__: 
 789              self._complainaboutunusedargs(_gen_p_lgvx8550_78,kwargs) 
 790          if len(args): 
 791              dict2={'sizeinbytes': 2,  'default': 0xffff } 
 792              dict2.update(kwargs) 
 793              kwargs=dict2 
 794              self.__field_numberindex=UINT(*args,**dict2) 
 795          # Make all P fields that haven't already been constructed 
 796   
 797   
 798 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 799          'Writes this packet to the supplied buffer' 
 800          self._bufferstartoffset=buf.getcurrentoffset() 
 801          self.__field_numberindex.writetobuffer(buf) 
 802          self._bufferendoffset=buf.getcurrentoffset() 
 803          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 804   
 805   
 806 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 807          'Reads this packet from the supplied buffer' 
 808          self._bufferstartoffset=buf.getcurrentoffset() 
 809          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 810          self.__field_numberindex=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
 811          self.__field_numberindex.readfrombuffer(buf) 
 812          self._bufferendoffset=buf.getcurrentoffset() 
 813   
 814   
 815 -    def __getfield_numberindex(self): 
 816          return self.__field_numberindex.getvalue() 
 817   
 818 -    def __setfield_numberindex(self, value): 
 819          if isinstance(value,UINT): 
 820              self.__field_numberindex=value 
 821          else: 
 822              self.__field_numberindex=UINT(value,**{'sizeinbytes': 2,  'default': 0xffff }) 
 823   
 824 -    def __delfield_numberindex(self): del self.__field_numberindex 
 825   
 826      numberindex=property(__getfield_numberindex, __setfield_numberindex, __delfield_numberindex, None) 
 827   
 828 -    def iscontainer(self): 
 829          return True 
 830   
 831 -    def containerelements(self): 
 832          yield ('numberindex', self.__field_numberindex, None) 
 833   
 834   
 835   
 836   
 837 -class pbfile(BaseProtogenClass): 
 838      __fields=['items', 'eof_tag', 'model_name', 'mod_date', 'blanks', 'eof_close_tag'] 
 839   
 840 -    def __init__(self, *args, **kwargs): 
 841          dict={} 
 842          # What was supplied to this function 
 843          dict.update(kwargs) 
 844          # Parent constructor 
 845          super(pbfile,self).__init__(**dict) 
 846          if self.__class__ is pbfile: 
 847              self._update(args,dict) 
 848   
 849   
 850 -    def getfields(self): 
 851          return self.__fields 
 852   
 853   
 854 -    def _update(self, args, kwargs): 
 855          super(pbfile,self)._update(args,kwargs) 
 856          keys=kwargs.keys() 
 857          for key in keys: 
 858              if key in self.__fields: 
 859                  setattr(self, key, kwargs[key]) 
 860                  del kwargs[key] 
 861          # Were any unrecognized kwargs passed in? 
 862          if __debug__: 
 863              self._complainaboutunusedargs(pbfile,kwargs) 
 864          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 865          # Make all P fields that haven't already been constructed 
 866   
 867   
 868 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 869          'Writes this packet to the supplied buffer' 
 870          self._bufferstartoffset=buf.getcurrentoffset() 
 871          try: self.__field_items 
 872          except: 
 873              self.__field_items=LIST(**{ 'elementclass': pbfileentry,             'length': NUMPHONEBOOKENTRIES,             'createdefault': True}) 
 874          self.__field_items.writetobuffer(buf) 
 875          try: self.__field_eof_tag 
 876          except: 
 877              self.__field_eof_tag=STRING(**{'sizeinbytes': 6,  'default': '<HPE>',               'raiseonunterminatedread': False,               'raiseontruncate': False }) 
 878          self.__field_eof_tag.writetobuffer(buf) 
 879          try: self.__field_model_name 
 880          except: 
 881              self.__field_model_name=STRING(**{'sizeinbytes': 10,  'raiseonunterminatedread': False,                'raiseontruncate': False }) 
 882          self.__field_model_name.writetobuffer(buf) 
 883          try: self.__field_mod_date 
 884          except: 
 885              self.__field_mod_date=PBDateTime(**{ 'defaulttocurrenttime': True }) 
 886          self.__field_mod_date.writetobuffer(buf) 
 887          try: self.__field_blanks 
 888          except: 
 889              self.__field_blanks=DATA(**{'sizeinbytes': 221,  'default': '\x00'*221 }) 
 890          self.__field_blanks.writetobuffer(buf) 
 891          try: self.__field_eof_close_tag 
 892          except: 
 893              self.__field_eof_close_tag=STRING(**{'sizeinbytes': 7,  'default': '</HPE>',               'raiseonunterminatedread': False,               'raiseontruncate': False  }) 
 894          self.__field_eof_close_tag.writetobuffer(buf) 
 895          self._bufferendoffset=buf.getcurrentoffset() 
 896          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 897   
 898   
 899 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 900          'Reads this packet from the supplied buffer' 
 901          self._bufferstartoffset=buf.getcurrentoffset() 
 902          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 903          self.__field_items=LIST(**{ 'elementclass': pbfileentry,             'length': NUMPHONEBOOKENTRIES,             'createdefault': True}) 
 904          self.__field_items.readfrombuffer(buf) 
 905          self.__field_eof_tag=STRING(**{'sizeinbytes': 6,  'default': '<HPE>',               'raiseonunterminatedread': False,               'raiseontruncate': False }) 
 906          self.__field_eof_tag.readfrombuffer(buf) 
 907          self.__field_model_name=STRING(**{'sizeinbytes': 10,  'raiseonunterminatedread': False,                'raiseontruncate': False }) 
 908          self.__field_model_name.readfrombuffer(buf) 
 909          self.__field_mod_date=PBDateTime(**{ 'defaulttocurrenttime': True }) 
 910          self.__field_mod_date.readfrombuffer(buf) 
 911          self.__field_blanks=DATA(**{'sizeinbytes': 221,  'default': '\x00'*221 }) 
 912          self.__field_blanks.readfrombuffer(buf) 
 913          self.__field_eof_close_tag=STRING(**{'sizeinbytes': 7,  'default': '</HPE>',               'raiseonunterminatedread': False,               'raiseontruncate': False  }) 
 914          self.__field_eof_close_tag.readfrombuffer(buf) 
 915          self._bufferendoffset=buf.getcurrentoffset() 
 916   
 917   
 918 -    def __getfield_items(self): 
 919          try: self.__field_items 
 920          except: 
 921              self.__field_items=LIST(**{ 'elementclass': pbfileentry,             'length': NUMPHONEBOOKENTRIES,             'createdefault': True}) 
 922          return self.__field_items.getvalue() 
 923   
 924 -    def __setfield_items(self, value): 
 925          if isinstance(value,LIST): 
 926              self.__field_items=value 
 927          else: 
 928              self.__field_items=LIST(value,**{ 'elementclass': pbfileentry,             'length': NUMPHONEBOOKENTRIES,             'createdefault': True}) 
 929   
 930 -    def __delfield_items(self): del self.__field_items 
 931   
 932      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
 933   
 934 -    def __getfield_eof_tag(self): 
 935          try: self.__field_eof_tag 
 936          except: 
 937              self.__field_eof_tag=STRING(**{'sizeinbytes': 6,  'default': '<HPE>',               'raiseonunterminatedread': False,               'raiseontruncate': False }) 
 938          return self.__field_eof_tag.getvalue() 
 939   
 940 -    def __setfield_eof_tag(self, value): 
 941          if isinstance(value,STRING): 
 942              self.__field_eof_tag=value 
 943          else: 
 944              self.__field_eof_tag=STRING(value,**{'sizeinbytes': 6,  'default': '<HPE>',               'raiseonunterminatedread': False,               'raiseontruncate': False }) 
 945   
 946 -    def __delfield_eof_tag(self): del self.__field_eof_tag 
 947   
 948      eof_tag=property(__getfield_eof_tag, __setfield_eof_tag, __delfield_eof_tag, None) 
 949   
 950 -    def __getfield_model_name(self): 
 951          try: self.__field_model_name 
 952          except: 
 953              self.__field_model_name=STRING(**{'sizeinbytes': 10,  'raiseonunterminatedread': False,                'raiseontruncate': False }) 
 954          return self.__field_model_name.getvalue() 
 955   
 956 -    def __setfield_model_name(self, value): 
 957          if isinstance(value,STRING): 
 958              self.__field_model_name=value 
 959          else: 
 960              self.__field_model_name=STRING(value,**{'sizeinbytes': 10,  'raiseonunterminatedread': False,                'raiseontruncate': False }) 
 961   
 962 -    def __delfield_model_name(self): del self.__field_model_name 
 963   
 964      model_name=property(__getfield_model_name, __setfield_model_name, __delfield_model_name, None) 
 965   
 966 -    def __getfield_mod_date(self): 
 967          try: self.__field_mod_date 
 968          except: 
 969              self.__field_mod_date=PBDateTime(**{ 'defaulttocurrenttime': True }) 
 970          return self.__field_mod_date.getvalue() 
 971   
 972 -    def __setfield_mod_date(self, value): 
 973          if isinstance(value,PBDateTime): 
 974              self.__field_mod_date=value 
 975          else: 
 976              self.__field_mod_date=PBDateTime(value,**{ 'defaulttocurrenttime': True }) 
 977   
 978 -    def __delfield_mod_date(self): del self.__field_mod_date 
 979   
 980      mod_date=property(__getfield_mod_date, __setfield_mod_date, __delfield_mod_date, None) 
 981   
 982 -    def __getfield_blanks(self): 
 983          try: self.__field_blanks 
 984          except: 
 985              self.__field_blanks=DATA(**{'sizeinbytes': 221,  'default': '\x00'*221 }) 
 986          return self.__field_blanks.getvalue() 
 987   
 988 -    def __setfield_blanks(self, value): 
 989          if isinstance(value,DATA): 
 990              self.__field_blanks=value 
 991          else: 
 992              self.__field_blanks=DATA(value,**{'sizeinbytes': 221,  'default': '\x00'*221 }) 
 993   
 994 -    def __delfield_blanks(self): del self.__field_blanks 
 995   
 996      blanks=property(__getfield_blanks, __setfield_blanks, __delfield_blanks, None) 
 997   
 998 -    def __getfield_eof_close_tag(self): 
 999          try: self.__field_eof_close_tag 
1000          except: 
1001              self.__field_eof_close_tag=STRING(**{'sizeinbytes': 7,  'default': '</HPE>',               'raiseonunterminatedread': False,               'raiseontruncate': False  }) 
1002          return self.__field_eof_close_tag.getvalue() 
1003   
1004 -    def __setfield_eof_close_tag(self, value): 
1005          if isinstance(value,STRING): 
1006              self.__field_eof_close_tag=value 
1007          else: 
1008              self.__field_eof_close_tag=STRING(value,**{'sizeinbytes': 7,  'default': '</HPE>',               'raiseonunterminatedread': False,               'raiseontruncate': False  }) 
1009   
1010 -    def __delfield_eof_close_tag(self): del self.__field_eof_close_tag 
1011   
1012      eof_close_tag=property(__getfield_eof_close_tag, __setfield_eof_close_tag, __delfield_eof_close_tag, None) 
1013   
1014 -    def iscontainer(self): 
1015          return True 
1016   
1017 -    def containerelements(self): 
1018          yield ('items', self.__field_items, None) 
1019          yield ('eof_tag', self.__field_eof_tag, None) 
1020          yield ('model_name', self.__field_model_name, None) 
1021          yield ('mod_date', self.__field_mod_date, None) 
1022          yield ('blanks', self.__field_blanks, None) 
1023          yield ('eof_close_tag', self.__field_eof_close_tag, None) 
1024   
1025   
1026   
1027   
1028 -class pnfileentry(BaseProtogenClass): 
1029      __fields=['entry_tag', 'pad00', 'mod_date', 'unk0', 'pn_id', 'pe_id', 'pn_order', 'phone_number', 'ntype', 'unk2', 'exit_tag', 'blanks'] 
1030   
1031 -    def __init__(self, *args, **kwargs): 
1032          dict={} 
1033          # What was supplied to this function 
1034          dict.update(kwargs) 
1035          # Parent constructor 
1036          super(pnfileentry,self).__init__(**dict) 
1037          if self.__class__ is pnfileentry: 
1038              self._update(args,dict) 
1039   
1040   
1041 -    def getfields(self): 
1042          return self.__fields 
1043   
1044   
1045 -    def _update(self, args, kwargs): 
1046          super(pnfileentry,self)._update(args,kwargs) 
1047          keys=kwargs.keys() 
1048          for key in keys: 
1049              if key in self.__fields: 
1050                  setattr(self, key, kwargs[key]) 
1051                  del kwargs[key] 
1052          # Were any unrecognized kwargs passed in? 
1053          if __debug__: 
1054              self._complainaboutunusedargs(pnfileentry,kwargs) 
1055          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1056          # Make all P fields that haven't already been constructed 
1057   
1058   
1059 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1060          'Writes this packet to the supplied buffer' 
1061          self._bufferstartoffset=buf.getcurrentoffset() 
1062          try: self.__field_entry_tag 
1063          except: 
1064              self.__field_entry_tag=STRING(**{'sizeinbytes': 4,  'terminator': None,                 'raiseonunterminatedread': False,                 'raiseontruncate': False,                 'default': '\xff\xff\xff\xff'}) 
1065          self.__field_entry_tag.writetobuffer(buf) 
1066          if self.entry_tag != '\xff\xff\xff\xff': 
1067              try: self.__field_pad00 
1068              except: 
1069                  self.__field_pad00=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
1070              self.__field_pad00.writetobuffer(buf) 
1071              try: self.__field_mod_date 
1072              except: 
1073                  self.__field_mod_date=PBDateTime(**{'defaulttocurrenttime': True }) 
1074              self.__field_mod_date.writetobuffer(buf) 
1075              try: self.__field_unk0 
1076              except: 
1077                  self.__field_unk0=STRING(**{'sizeinbytes': 6,  'default': '', 'raiseonunterminatedread': False }) 
1078              self.__field_unk0.writetobuffer(buf) 
1079              self.__field_pn_id.writetobuffer(buf) 
1080              self.__field_pe_id.writetobuffer(buf) 
1081              self.__field_pn_order.writetobuffer(buf) 
1082              self.__field_phone_number.writetobuffer(buf) 
1083              self.__field_ntype.writetobuffer(buf) 
1084              try: self.__field_unk2 
1085              except: 
1086                  self.__field_unk2=UINT(**{'sizeinbytes': 3,  'default': 0 }) 
1087              self.__field_unk2.writetobuffer(buf) 
1088              try: self.__field_exit_tag 
1089              except: 
1090                  self.__field_exit_tag=USTRING(**{'sizeinbytes': 6,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '</PN>'}) 
1091              self.__field_exit_tag.writetobuffer(buf) 
1092          else: 
1093              try: self.__field_blanks 
1094              except: 
1095                  self.__field_blanks=DATA(**{'sizeinbytes': 60,  'default': '\xFF'*60 }) 
1096              self.__field_blanks.writetobuffer(buf) 
1097          self._bufferendoffset=buf.getcurrentoffset() 
1098          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1099   
1100   
1101 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1102          'Reads this packet from the supplied buffer' 
1103          self._bufferstartoffset=buf.getcurrentoffset() 
1104          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1105          self.__field_entry_tag=STRING(**{'sizeinbytes': 4,  'terminator': None,                 'raiseonunterminatedread': False,                 'raiseontruncate': False,                 'default': '\xff\xff\xff\xff'}) 
1106          self.__field_entry_tag.readfrombuffer(buf) 
1107          if self.entry_tag != '\xff\xff\xff\xff': 
1108              self.__field_pad00=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
1109              self.__field_pad00.readfrombuffer(buf) 
1110              self.__field_mod_date=PBDateTime(**{'defaulttocurrenttime': True }) 
1111              self.__field_mod_date.readfrombuffer(buf) 
1112              self.__field_unk0=STRING(**{'sizeinbytes': 6,  'default': '', 'raiseonunterminatedread': False }) 
1113              self.__field_unk0.readfrombuffer(buf) 
1114              self.__field_pn_id=UINT(**{'sizeinbytes': 2}) 
1115              self.__field_pn_id.readfrombuffer(buf) 
1116              self.__field_pe_id=UINT(**{'sizeinbytes': 2}) 
1117              self.__field_pe_id.readfrombuffer(buf) 
1118              self.__field_pn_order=UINT(**{'sizeinbytes': 1}) 
1119              self.__field_pn_order.readfrombuffer(buf) 
1120              self.__field_phone_number=LGHEXPN(**{'sizeinbytes': 25}) 
1121              self.__field_phone_number.readfrombuffer(buf) 
1122              self.__field_ntype=UINT(**{'sizeinbytes': 2}) 
1123              self.__field_ntype.readfrombuffer(buf) 
1124              self.__field_unk2=UINT(**{'sizeinbytes': 3,  'default': 0 }) 
1125              self.__field_unk2.readfrombuffer(buf) 
1126              self.__field_exit_tag=USTRING(**{'sizeinbytes': 6,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '</PN>'}) 
1127              self.__field_exit_tag.readfrombuffer(buf) 
1128          else: 
1129              self.__field_blanks=DATA(**{'sizeinbytes': 60,  'default': '\xFF'*60 }) 
1130              self.__field_blanks.readfrombuffer(buf) 
1131          self._bufferendoffset=buf.getcurrentoffset() 
1132   
1133   
1134 -    def __getfield_entry_tag(self): 
1135          try: self.__field_entry_tag 
1136          except: 
1137              self.__field_entry_tag=STRING(**{'sizeinbytes': 4,  'terminator': None,                 'raiseonunterminatedread': False,                 'raiseontruncate': False,                 'default': '\xff\xff\xff\xff'}) 
1138          return self.__field_entry_tag.getvalue() 
1139   
1140 -    def __setfield_entry_tag(self, value): 
1141          if isinstance(value,STRING): 
1142              self.__field_entry_tag=value 
1143          else: 
1144              self.__field_entry_tag=STRING(value,**{'sizeinbytes': 4,  'terminator': None,                 'raiseonunterminatedread': False,                 'raiseontruncate': False,                 'default': '\xff\xff\xff\xff'}) 
1145   
1146 -    def __delfield_entry_tag(self): del self.__field_entry_tag 
1147   
1148      entry_tag=property(__getfield_entry_tag, __setfield_entry_tag, __delfield_entry_tag, None) 
1149   
1150 -    def __getfield_pad00(self): 
1151          try: self.__field_pad00 
1152          except: 
1153              self.__field_pad00=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
1154          return self.__field_pad00.getvalue() 
1155   
1156 -    def __setfield_pad00(self, value): 
1157          if isinstance(value,UINT): 
1158              self.__field_pad00=value 
1159          else: 
1160              self.__field_pad00=UINT(value,**{'sizeinbytes': 1,  'default': 0 }) 
1161   
1162 -    def __delfield_pad00(self): del self.__field_pad00 
1163   
1164      pad00=property(__getfield_pad00, __setfield_pad00, __delfield_pad00, None) 
1165   
1166 -    def __getfield_mod_date(self): 
1167          try: self.__field_mod_date 
1168          except: 
1169              self.__field_mod_date=PBDateTime(**{'defaulttocurrenttime': True }) 
1170          return self.__field_mod_date.getvalue() 
1171   
1172 -    def __setfield_mod_date(self, value): 
1173          if isinstance(value,PBDateTime): 
1174              self.__field_mod_date=value 
1175          else: 
1176              self.__field_mod_date=PBDateTime(value,**{'defaulttocurrenttime': True }) 
1177   
1178 -    def __delfield_mod_date(self): del self.__field_mod_date 
1179   
1180      mod_date=property(__getfield_mod_date, __setfield_mod_date, __delfield_mod_date, None) 
1181   
1182 -    def __getfield_unk0(self): 
1183          try: self.__field_unk0 
1184          except: 
1185              self.__field_unk0=STRING(**{'sizeinbytes': 6,  'default': '', 'raiseonunterminatedread': False }) 
1186          return self.__field_unk0.getvalue() 
1187   
1188 -    def __setfield_unk0(self, value): 
1189          if isinstance(value,STRING): 
1190              self.__field_unk0=value 
1191          else: 
1192              self.__field_unk0=STRING(value,**{'sizeinbytes': 6,  'default': '', 'raiseonunterminatedread': False }) 
1193   
1194 -    def __delfield_unk0(self): del self.__field_unk0 
1195   
1196      unk0=property(__getfield_unk0, __setfield_unk0, __delfield_unk0, None) 
1197   
1198 -    def __getfield_pn_id(self): 
1199          return self.__field_pn_id.getvalue() 
1200   
1201 -    def __setfield_pn_id(self, value): 
1202          if isinstance(value,UINT): 
1203              self.__field_pn_id=value 
1204          else: 
1205              self.__field_pn_id=UINT(value,**{'sizeinbytes': 2}) 
1206   
1207 -    def __delfield_pn_id(self): del self.__field_pn_id 
1208   
1209      pn_id=property(__getfield_pn_id, __setfield_pn_id, __delfield_pn_id, None) 
1210   
1211 -    def __getfield_pe_id(self): 
1212          return self.__field_pe_id.getvalue() 
1213   
1214 -    def __setfield_pe_id(self, value): 
1215          if isinstance(value,UINT): 
1216              self.__field_pe_id=value 
1217          else: 
1218              self.__field_pe_id=UINT(value,**{'sizeinbytes': 2}) 
1219   
1220 -    def __delfield_pe_id(self): del self.__field_pe_id 
1221   
1222      pe_id=property(__getfield_pe_id, __setfield_pe_id, __delfield_pe_id, None) 
1223   
1224 -    def __getfield_pn_order(self): 
1225          return self.__field_pn_order.getvalue() 
1226   
1227 -    def __setfield_pn_order(self, value): 
1228          if isinstance(value,UINT): 
1229              self.__field_pn_order=value 
1230          else: 
1231              self.__field_pn_order=UINT(value,**{'sizeinbytes': 1}) 
1232   
1233 -    def __delfield_pn_order(self): del self.__field_pn_order 
1234   
1235      pn_order=property(__getfield_pn_order, __setfield_pn_order, __delfield_pn_order, "0-based order of this phone within this contact") 
1236   
1237 -    def __getfield_phone_number(self): 
1238          return self.__field_phone_number.getvalue() 
1239   
1240 -    def __setfield_phone_number(self, value): 
1241          if isinstance(value,LGHEXPN): 
1242              self.__field_phone_number=value 
1243          else: 
1244              self.__field_phone_number=LGHEXPN(value,**{'sizeinbytes': 25}) 
1245   
1246 -    def __delfield_phone_number(self): del self.__field_phone_number 
1247   
1248      phone_number=property(__getfield_phone_number, __setfield_phone_number, __delfield_phone_number, None) 
1249   
1250 -    def __getfield_ntype(self): 
1251          return self.__field_ntype.getvalue() 
1252   
1253 -    def __setfield_ntype(self, value): 
1254          if isinstance(value,UINT): 
1255              self.__field_ntype=value 
1256          else: 
1257              self.__field_ntype=UINT(value,**{'sizeinbytes': 2}) 
1258   
1259 -    def __delfield_ntype(self): del self.__field_ntype 
1260   
1261      ntype=property(__getfield_ntype, __setfield_ntype, __delfield_ntype, None) 
1262   
1263 -    def __getfield_unk2(self): 
1264          try: self.__field_unk2 
1265          except: 
1266              self.__field_unk2=UINT(**{'sizeinbytes': 3,  'default': 0 }) 
1267          return self.__field_unk2.getvalue() 
1268   
1269 -    def __setfield_unk2(self, value): 
1270          if isinstance(value,UINT): 
1271              self.__field_unk2=value 
1272          else: 
1273              self.__field_unk2=UINT(value,**{'sizeinbytes': 3,  'default': 0 }) 
1274   
1275 -    def __delfield_unk2(self): del self.__field_unk2 
1276   
1277      unk2=property(__getfield_unk2, __setfield_unk2, __delfield_unk2, None) 
1278   
1279 -    def __getfield_exit_tag(self): 
1280          try: self.__field_exit_tag 
1281          except: 
1282              self.__field_exit_tag=USTRING(**{'sizeinbytes': 6,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '</PN>'}) 
1283          return self.__field_exit_tag.getvalue() 
1284   
1285 -    def __setfield_exit_tag(self, value): 
1286          if isinstance(value,USTRING): 
1287              self.__field_exit_tag=value 
1288          else: 
1289              self.__field_exit_tag=USTRING(value,**{'sizeinbytes': 6,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '</PN>'}) 
1290   
1291 -    def __delfield_exit_tag(self): del self.__field_exit_tag 
1292   
1293      exit_tag=property(__getfield_exit_tag, __setfield_exit_tag, __delfield_exit_tag, None) 
1294   
1295 -    def __getfield_blanks(self): 
1296          try: self.__field_blanks 
1297          except: 
1298              self.__field_blanks=DATA(**{'sizeinbytes': 60,  'default': '\xFF'*60 }) 
1299          return self.__field_blanks.getvalue() 
1300   
1301 -    def __setfield_blanks(self, value): 
1302          if isinstance(value,DATA): 
1303              self.__field_blanks=value 
1304          else: 
1305              self.__field_blanks=DATA(value,**{'sizeinbytes': 60,  'default': '\xFF'*60 }) 
1306   
1307 -    def __delfield_blanks(self): del self.__field_blanks 
1308   
1309      blanks=property(__getfield_blanks, __setfield_blanks, __delfield_blanks, None) 
1310   
1311 -    def iscontainer(self): 
1312          return True 
1313   
1314 -    def containerelements(self): 
1315          yield ('entry_tag', self.__field_entry_tag, None) 
1316          if self.entry_tag != '\xff\xff\xff\xff': 
1317              yield ('pad00', self.__field_pad00, None) 
1318              yield ('mod_date', self.__field_mod_date, None) 
1319              yield ('unk0', self.__field_unk0, None) 
1320              yield ('pn_id', self.__field_pn_id, None) 
1321              yield ('pe_id', self.__field_pe_id, None) 
1322              yield ('pn_order', self.__field_pn_order, "0-based order of this phone within this contact") 
1323              yield ('phone_number', self.__field_phone_number, None) 
1324              yield ('ntype', self.__field_ntype, None) 
1325              yield ('unk2', self.__field_unk2, None) 
1326              yield ('exit_tag', self.__field_exit_tag, None) 
1327          else: 
1328              yield ('blanks', self.__field_blanks, None) 
1329   
1330 -    def valid(self): 
1331           return self.phone_number != None 
1332 -    def malformed(self): 
1333           # malformed (yet valid) entries have been seen on several phones including the VX-8550 and VX-10000 
1334           return self.entry_tag != PB_NUMBER_SOR 
1335   
1336   
1337   
1338   
1339 -class pnfile(BaseProtogenClass): 
1340      __fields=['items'] 
1341   
1342 -    def __init__(self, *args, **kwargs): 
1343          dict={} 
1344          # What was supplied to this function 
1345          dict.update(kwargs) 
1346          # Parent constructor 
1347          super(pnfile,self).__init__(**dict) 
1348          if self.__class__ is pnfile: 
1349              self._update(args,dict) 
1350   
1351   
1352 -    def getfields(self): 
1353          return self.__fields 
1354   
1355   
1356 -    def _update(self, args, kwargs): 
1357          super(pnfile,self)._update(args,kwargs) 
1358          keys=kwargs.keys() 
1359          for key in keys: 
1360              if key in self.__fields: 
1361                  setattr(self, key, kwargs[key]) 
1362                  del kwargs[key] 
1363          # Were any unrecognized kwargs passed in? 
1364          if __debug__: 
1365              self._complainaboutunusedargs(pnfile,kwargs) 
1366          if len(args): 
1367              dict2={ 'elementclass': pnfileentry,             'createdefault': True,             'length': NUMPHONENUMBERENTRIES } 
1368              dict2.update(kwargs) 
1369              kwargs=dict2 
1370              self.__field_items=LIST(*args,**dict2) 
1371          # Make all P fields that haven't already been constructed 
1372   
1373   
1374 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1375          'Writes this packet to the supplied buffer' 
1376          self._bufferstartoffset=buf.getcurrentoffset() 
1377          try: self.__field_items 
1378          except: 
1379              self.__field_items=LIST(**{ 'elementclass': pnfileentry,             'createdefault': True,             'length': NUMPHONENUMBERENTRIES }) 
1380          self.__field_items.writetobuffer(buf) 
1381          self._bufferendoffset=buf.getcurrentoffset() 
1382          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1383   
1384   
1385 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1386          'Reads this packet from the supplied buffer' 
1387          self._bufferstartoffset=buf.getcurrentoffset() 
1388          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1389          self.__field_items=LIST(**{ 'elementclass': pnfileentry,             'createdefault': True,             'length': NUMPHONENUMBERENTRIES }) 
1390          self.__field_items.readfrombuffer(buf) 
1391          self._bufferendoffset=buf.getcurrentoffset() 
1392   
1393   
1394 -    def __getfield_items(self): 
1395          try: self.__field_items 
1396          except: 
1397              self.__field_items=LIST(**{ 'elementclass': pnfileentry,             'createdefault': True,             'length': NUMPHONENUMBERENTRIES }) 
1398          return self.__field_items.getvalue() 
1399   
1400 -    def __setfield_items(self, value): 
1401          if isinstance(value,LIST): 
1402              self.__field_items=value 
1403          else: 
1404              self.__field_items=LIST(value,**{ 'elementclass': pnfileentry,             'createdefault': True,             'length': NUMPHONENUMBERENTRIES }) 
1405   
1406 -    def __delfield_items(self): del self.__field_items 
1407   
1408      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
1409   
1410 -    def iscontainer(self): 
1411          return True 
1412   
1413 -    def containerelements(self): 
1414          yield ('items', self.__field_items, None) 
1415   
1416   
1417   
1418   
1419 -class PathIndexEntry(BaseProtogenClass): 
1420      __fields=['pathname'] 
1421   
1422 -    def __init__(self, *args, **kwargs): 
1423          dict={} 
1424          # What was supplied to this function 
1425          dict.update(kwargs) 
1426          # Parent constructor 
1427          super(PathIndexEntry,self).__init__(**dict) 
1428          if self.__class__ is PathIndexEntry: 
1429              self._update(args,dict) 
1430   
1431   
1432 -    def getfields(self): 
1433          return self.__fields 
1434   
1435   
1436 -    def _update(self, args, kwargs): 
1437          super(PathIndexEntry,self)._update(args,kwargs) 
1438          keys=kwargs.keys() 
1439          for key in keys: 
1440              if key in self.__fields: 
1441                  setattr(self, key, kwargs[key]) 
1442                  del kwargs[key] 
1443          # Were any unrecognized kwargs passed in? 
1444          if __debug__: 
1445              self._complainaboutunusedargs(PathIndexEntry,kwargs) 
1446          if len(args): 
1447              dict2={'sizeinbytes': 255,  'encoding': PHONE_ENCODING,                  'default': '' } 
1448              dict2.update(kwargs) 
1449              kwargs=dict2 
1450              self.__field_pathname=USTRING(*args,**dict2) 
1451          # Make all P fields that haven't already been constructed 
1452   
1453   
1454 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1455          'Writes this packet to the supplied buffer' 
1456          self._bufferstartoffset=buf.getcurrentoffset() 
1457          try: self.__field_pathname 
1458          except: 
1459              self.__field_pathname=USTRING(**{'sizeinbytes': 255,  'encoding': PHONE_ENCODING,                  'default': '' }) 
1460          self.__field_pathname.writetobuffer(buf) 
1461          self._bufferendoffset=buf.getcurrentoffset() 
1462          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1463   
1464   
1465 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1466          'Reads this packet from the supplied buffer' 
1467          self._bufferstartoffset=buf.getcurrentoffset() 
1468          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1469          self.__field_pathname=USTRING(**{'sizeinbytes': 255,  'encoding': PHONE_ENCODING,                  'default': '' }) 
1470          self.__field_pathname.readfrombuffer(buf) 
1471          self._bufferendoffset=buf.getcurrentoffset() 
1472   
1473   
1474 -    def __getfield_pathname(self): 
1475          try: self.__field_pathname 
1476          except: 
1477              self.__field_pathname=USTRING(**{'sizeinbytes': 255,  'encoding': PHONE_ENCODING,                  'default': '' }) 
1478          return self.__field_pathname.getvalue() 
1479   
1480 -    def __setfield_pathname(self, value): 
1481          if isinstance(value,USTRING): 
1482              self.__field_pathname=value 
1483          else: 
1484              self.__field_pathname=USTRING(value,**{'sizeinbytes': 255,  'encoding': PHONE_ENCODING,                  'default': '' }) 
1485   
1486 -    def __delfield_pathname(self): del self.__field_pathname 
1487   
1488      pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None) 
1489   
1490 -    def iscontainer(self): 
1491          return True 
1492   
1493 -    def containerelements(self): 
1494          yield ('pathname', self.__field_pathname, None) 
1495   
1496   
1497   
1498   
1499 -class PathIndexFile(BaseProtogenClass): 
1500      __fields=['items'] 
1501   
1502 -    def __init__(self, *args, **kwargs): 
1503          dict={} 
1504          # What was supplied to this function 
1505          dict.update(kwargs) 
1506          # Parent constructor 
1507          super(PathIndexFile,self).__init__(**dict) 
1508          if self.__class__ is PathIndexFile: 
1509              self._update(args,dict) 
1510   
1511   
1512 -    def getfields(self): 
1513          return self.__fields 
1514   
1515   
1516 -    def _update(self, args, kwargs): 
1517          super(PathIndexFile,self)._update(args,kwargs) 
1518          keys=kwargs.keys() 
1519          for key in keys: 
1520              if key in self.__fields: 
1521                  setattr(self, key, kwargs[key]) 
1522                  del kwargs[key] 
1523          # Were any unrecognized kwargs passed in? 
1524          if __debug__: 
1525              self._complainaboutunusedargs(PathIndexFile,kwargs) 
1526          if len(args): 
1527              dict2={ 'elementclass': PathIndexEntry,             'createdefault': True,             'length': NUMPHONEBOOKENTRIES } 
1528              dict2.update(kwargs) 
1529              kwargs=dict2 
1530              self.__field_items=LIST(*args,**dict2) 
1531          # Make all P fields that haven't already been constructed 
1532   
1533   
1534 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1535          'Writes this packet to the supplied buffer' 
1536          self._bufferstartoffset=buf.getcurrentoffset() 
1537          try: self.__field_items 
1538          except: 
1539              self.__field_items=LIST(**{ 'elementclass': PathIndexEntry,             'createdefault': True,             'length': NUMPHONEBOOKENTRIES }) 
1540          self.__field_items.writetobuffer(buf) 
1541          self._bufferendoffset=buf.getcurrentoffset() 
1542          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1543   
1544   
1545 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1546          'Reads this packet from the supplied buffer' 
1547          self._bufferstartoffset=buf.getcurrentoffset() 
1548          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1549          self.__field_items=LIST(**{ 'elementclass': PathIndexEntry,             'createdefault': True,             'length': NUMPHONEBOOKENTRIES }) 
1550          self.__field_items.readfrombuffer(buf) 
1551          self._bufferendoffset=buf.getcurrentoffset() 
1552   
1553   
1554 -    def __getfield_items(self): 
1555          try: self.__field_items 
1556          except: 
1557              self.__field_items=LIST(**{ 'elementclass': PathIndexEntry,             'createdefault': True,             'length': NUMPHONEBOOKENTRIES }) 
1558          return self.__field_items.getvalue() 
1559   
1560 -    def __setfield_items(self, value): 
1561          if isinstance(value,LIST): 
1562              self.__field_items=value 
1563          else: 
1564              self.__field_items=LIST(value,**{ 'elementclass': PathIndexEntry,             'createdefault': True,             'length': NUMPHONEBOOKENTRIES }) 
1565   
1566 -    def __delfield_items(self): del self.__field_items 
1567   
1568      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
1569   
1570 -    def iscontainer(self): 
1571          return True 
1572   
1573 -    def containerelements(self): 
1574          yield ('items', self.__field_items, None) 
1575   
1576   
1577   
1578   
1579 -class RecordIdEntry(BaseProtogenClass): 
1580      __fields=['idnum'] 
1581   
1582 -    def __init__(self, *args, **kwargs): 
1583          dict={} 
1584          # What was supplied to this function 
1585          dict.update(kwargs) 
1586          # Parent constructor 
1587          super(RecordIdEntry,self).__init__(**dict) 
1588          if self.__class__ is RecordIdEntry: 
1589              self._update(args,dict) 
1590   
1591   
1592 -    def getfields(self): 
1593          return self.__fields 
1594   
1595   
1596 -    def _update(self, args, kwargs): 
1597          super(RecordIdEntry,self)._update(args,kwargs) 
1598          keys=kwargs.keys() 
1599          for key in keys: 
1600              if key in self.__fields: 
1601                  setattr(self, key, kwargs[key]) 
1602                  del kwargs[key] 
1603          # Were any unrecognized kwargs passed in? 
1604          if __debug__: 
1605              self._complainaboutunusedargs(RecordIdEntry,kwargs) 
1606          if len(args): 
1607              dict2={'sizeinbytes': 4} 
1608              dict2.update(kwargs) 
1609              kwargs=dict2 
1610              self.__field_idnum=UINT(*args,**dict2) 
1611          # Make all P fields that haven't already been constructed 
1612   
1613   
1614 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1615          'Writes this packet to the supplied buffer' 
1616          self._bufferstartoffset=buf.getcurrentoffset() 
1617          self.__field_idnum.writetobuffer(buf) 
1618          self._bufferendoffset=buf.getcurrentoffset() 
1619          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1620   
1621   
1622 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1623          'Reads this packet from the supplied buffer' 
1624          self._bufferstartoffset=buf.getcurrentoffset() 
1625          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1626          self.__field_idnum=UINT(**{'sizeinbytes': 4}) 
1627          self.__field_idnum.readfrombuffer(buf) 
1628          self._bufferendoffset=buf.getcurrentoffset() 
1629   
1630   
1631 -    def __getfield_idnum(self): 
1632          return self.__field_idnum.getvalue() 
1633   
1634 -    def __setfield_idnum(self, value): 
1635          if isinstance(value,UINT): 
1636              self.__field_idnum=value 
1637          else: 
1638              self.__field_idnum=UINT(value,**{'sizeinbytes': 4}) 
1639   
1640 -    def __delfield_idnum(self): del self.__field_idnum 
1641   
1642      idnum=property(__getfield_idnum, __setfield_idnum, __delfield_idnum, None) 
1643   
1644 -    def iscontainer(self): 
1645          return True 
1646   
1647 -    def containerelements(self): 
1648          yield ('idnum', self.__field_idnum, None) 
1649   
1650   
1651   
1652   
1653 -class iceentry(BaseProtogenClass): 
1654      "ICE index entries" 
1655      __fields=['entry_assigned', 'entry_number', 'pb_index', 'dontcare'] 
1656   
1657 -    def __init__(self, *args, **kwargs): 
1658          dict={} 
1659          # What was supplied to this function 
1660          dict.update(kwargs) 
1661          # Parent constructor 
1662          super(iceentry,self).__init__(**dict) 
1663          if self.__class__ is iceentry: 
1664              self._update(args,dict) 
1665   
1666   
1667 -    def getfields(self): 
1668          return self.__fields 
1669   
1670   
1671 -    def _update(self, args, kwargs): 
1672          super(iceentry,self)._update(args,kwargs) 
1673          keys=kwargs.keys() 
1674          for key in keys: 
1675              if key in self.__fields: 
1676                  setattr(self, key, kwargs[key]) 
1677                  del kwargs[key] 
1678          # Were any unrecognized kwargs passed in? 
1679          if __debug__: 
1680              self._complainaboutunusedargs(iceentry,kwargs) 
1681          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1682          # Make all P fields that haven't already been constructed 
1683   
1684   
1685 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1686          'Writes this packet to the supplied buffer' 
1687          self._bufferstartoffset=buf.getcurrentoffset() 
1688          try: self.__field_entry_assigned 
1689          except: 
1690              self.__field_entry_assigned=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1691          self.__field_entry_assigned.writetobuffer(buf) 
1692          try: self.__field_entry_number 
1693          except: 
1694              self.__field_entry_number=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
1695          self.__field_entry_number.writetobuffer(buf) 
1696          try: self.__field_pb_index 
1697          except: 
1698              self.__field_pb_index=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1699          self.__field_pb_index.writetobuffer(buf) 
1700          try: self.__field_dontcare 
1701          except: 
1702              self.__field_dontcare=DATA(**{'sizeinbytes': 82,  'default': '\x00'*82 }) 
1703          self.__field_dontcare.writetobuffer(buf) 
1704          self._bufferendoffset=buf.getcurrentoffset() 
1705          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1706   
1707   
1708 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1709          'Reads this packet from the supplied buffer' 
1710          self._bufferstartoffset=buf.getcurrentoffset() 
1711          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1712          self.__field_entry_assigned=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1713          self.__field_entry_assigned.readfrombuffer(buf) 
1714          self.__field_entry_number=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
1715          self.__field_entry_number.readfrombuffer(buf) 
1716          self.__field_pb_index=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1717          self.__field_pb_index.readfrombuffer(buf) 
1718          self.__field_dontcare=DATA(**{'sizeinbytes': 82,  'default': '\x00'*82 }) 
1719          self.__field_dontcare.readfrombuffer(buf) 
1720          self._bufferendoffset=buf.getcurrentoffset() 
1721   
1722   
1723 -    def __getfield_entry_assigned(self): 
1724          try: self.__field_entry_assigned 
1725          except: 
1726              self.__field_entry_assigned=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1727          return self.__field_entry_assigned.getvalue() 
1728   
1729 -    def __setfield_entry_assigned(self, value): 
1730          if isinstance(value,UINT): 
1731              self.__field_entry_assigned=value 
1732          else: 
1733              self.__field_entry_assigned=UINT(value,**{'sizeinbytes': 2,  'default': 0 }) 
1734   
1735 -    def __delfield_entry_assigned(self): del self.__field_entry_assigned 
1736   
1737      entry_assigned=property(__getfield_entry_assigned, __setfield_entry_assigned, __delfield_entry_assigned, "0 if not assigned, 1 if assigned") 
1738   
1739 -    def __getfield_entry_number(self): 
1740          try: self.__field_entry_number 
1741          except: 
1742              self.__field_entry_number=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
1743          return self.__field_entry_number.getvalue() 
1744   
1745 -    def __setfield_entry_number(self, value): 
1746          if isinstance(value,UINT): 
1747              self.__field_entry_number=value 
1748          else: 
1749              self.__field_entry_number=UINT(value,**{'sizeinbytes': 2,  'default': 0xffff }) 
1750   
1751 -    def __delfield_entry_number(self): del self.__field_entry_number 
1752   
1753      entry_number=property(__getfield_entry_number, __setfield_entry_number, __delfield_entry_number, "0-based ICE entry number") 
1754   
1755 -    def __getfield_pb_index(self): 
1756          try: self.__field_pb_index 
1757          except: 
1758              self.__field_pb_index=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1759          return self.__field_pb_index.getvalue() 
1760   
1761 -    def __setfield_pb_index(self, value): 
1762          if isinstance(value,UINT): 
1763              self.__field_pb_index=value 
1764          else: 
1765              self.__field_pb_index=UINT(value,**{'sizeinbytes': 2,  'default': 0 }) 
1766   
1767 -    def __delfield_pb_index(self): del self.__field_pb_index 
1768   
1769      pb_index=property(__getfield_pb_index, __setfield_pb_index, __delfield_pb_index, "0-based phone book entry number") 
1770   
1771 -    def __getfield_dontcare(self): 
1772          try: self.__field_dontcare 
1773          except: 
1774              self.__field_dontcare=DATA(**{'sizeinbytes': 82,  'default': '\x00'*82 }) 
1775          return self.__field_dontcare.getvalue() 
1776   
1777 -    def __setfield_dontcare(self, value): 
1778          if isinstance(value,DATA): 
1779              self.__field_dontcare=value 
1780          else: 
1781              self.__field_dontcare=DATA(value,**{'sizeinbytes': 82,  'default': '\x00'*82 }) 
1782   
1783 -    def __delfield_dontcare(self): del self.__field_dontcare 
1784   
1785      dontcare=property(__getfield_dontcare, __setfield_dontcare, __delfield_dontcare, None) 
1786   
1787 -    def iscontainer(self): 
1788          return True 
1789   
1790 -    def containerelements(self): 
1791          yield ('entry_assigned', self.__field_entry_assigned, "0 if not assigned, 1 if assigned") 
1792          yield ('entry_number', self.__field_entry_number, "0-based ICE entry number") 
1793          yield ('pb_index', self.__field_pb_index, "0-based phone book entry number") 
1794          yield ('dontcare', self.__field_dontcare, None) 
1795   
1796 -    def valid(self): 
1797          return self.entry_assigned==1 and \ 
1798                 self.entry_number<NUMEMERGENCYCONTACTS and \ 
1799                 self.pb_index<NUMPHONEBOOKENTRIES 
1800   
1801   
1802   
1803   
1804 -class iceentryfile(BaseProtogenClass): 
1805      __fields=['items'] 
1806   
1807 -    def __init__(self, *args, **kwargs): 
1808          dict={} 
1809          # What was supplied to this function 
1810          dict.update(kwargs) 
1811          # Parent constructor 
1812          super(iceentryfile,self).__init__(**dict) 
1813          if self.__class__ is iceentryfile: 
1814              self._update(args,dict) 
1815   
1816   
1817 -    def getfields(self): 
1818          return self.__fields 
1819   
1820   
1821 -    def _update(self, args, kwargs): 
1822          super(iceentryfile,self)._update(args,kwargs) 
1823          keys=kwargs.keys() 
1824          for key in keys: 
1825              if key in self.__fields: 
1826                  setattr(self, key, kwargs[key]) 
1827                  del kwargs[key] 
1828          # Were any unrecognized kwargs passed in? 
1829          if __debug__: 
1830              self._complainaboutunusedargs(iceentryfile,kwargs) 
1831          if len(args): 
1832              dict2={ 'elementclass': iceentry,              'createdefault': True,              'length': NUMEMERGENCYCONTACTS } 
1833              dict2.update(kwargs) 
1834              kwargs=dict2 
1835              self.__field_items=LIST(*args,**dict2) 
1836          # Make all P fields that haven't already been constructed 
1837   
1838   
1839 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1840          'Writes this packet to the supplied buffer' 
1841          self._bufferstartoffset=buf.getcurrentoffset() 
1842          try: self.__field_items 
1843          except: 
1844              self.__field_items=LIST(**{ 'elementclass': iceentry,              'createdefault': True,              'length': NUMEMERGENCYCONTACTS }) 
1845          self.__field_items.writetobuffer(buf) 
1846          self._bufferendoffset=buf.getcurrentoffset() 
1847          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1848   
1849   
1850 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1851          'Reads this packet from the supplied buffer' 
1852          self._bufferstartoffset=buf.getcurrentoffset() 
1853          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1854          self.__field_items=LIST(**{ 'elementclass': iceentry,              'createdefault': True,              'length': NUMEMERGENCYCONTACTS }) 
1855          self.__field_items.readfrombuffer(buf) 
1856          self._bufferendoffset=buf.getcurrentoffset() 
1857   
1858   
1859 -    def __getfield_items(self): 
1860          try: self.__field_items 
1861          except: 
1862              self.__field_items=LIST(**{ 'elementclass': iceentry,              'createdefault': True,              'length': NUMEMERGENCYCONTACTS }) 
1863          return self.__field_items.getvalue() 
1864   
1865 -    def __setfield_items(self, value): 
1866          if isinstance(value,LIST): 
1867              self.__field_items=value 
1868          else: 
1869              self.__field_items=LIST(value,**{ 'elementclass': iceentry,              'createdefault': True,              'length': NUMEMERGENCYCONTACTS }) 
1870   
1871 -    def __delfield_items(self): del self.__field_items 
1872   
1873      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
1874   
1875 -    def iscontainer(self): 
1876          return True 
1877   
1878 -    def containerelements(self): 
1879          yield ('items', self.__field_items, None) 
1880   
1881   
1882   
1883   
1884 -class scheduleevent(BaseProtogenClass): 
1885      __fields=['packet_size', 'pos', 'description', 'cdate', 'mdate', 'start', 'end_time', 'end_date', 'repeat', 'alarmindex_vibrate', 'ringtone', 'unknown1', 'alarmminutes', 'alarmhours', 'unknown2', 'unknown3', 'unknown4', 'serial_number'] 
1886   
1887 -    def __init__(self, *args, **kwargs): 
1888          dict={} 
1889          # What was supplied to this function 
1890          dict.update(kwargs) 
1891          # Parent constructor 
1892          super(scheduleevent,self).__init__(**dict) 
1893          if self.__class__ is scheduleevent: 
1894              self._update(args,dict) 
1895   
1896   
1897 -    def getfields(self): 
1898          return self.__fields 
1899   
1900   
1901 -    def _update(self, args, kwargs): 
1902          super(scheduleevent,self)._update(args,kwargs) 
1903          keys=kwargs.keys() 
1904          for key in keys: 
1905              if key in self.__fields: 
1906                  setattr(self, key, kwargs[key]) 
1907                  del kwargs[key] 
1908          # Were any unrecognized kwargs passed in? 
1909          if __debug__: 
1910              self._complainaboutunusedargs(scheduleevent,kwargs) 
1911          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1912          # Make all P fields that haven't already been constructed 
1913          try: self.__field_packet_size 
1914          except: 
1915              self.__field_packet_size=UINT(**{ 'constant': 138 }) 
1916   
1917   
1918 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1919          'Writes this packet to the supplied buffer' 
1920          self._bufferstartoffset=buf.getcurrentoffset() 
1921          try: self.__field_pos 
1922          except: 
1923              self.__field_pos=UINT(**{'sizeinbytes': 4,  'default': 0 }) 
1924          self.__field_pos.writetobuffer(buf) 
1925          try: self.__field_description 
1926          except: 
1927              self.__field_description=USTRING(**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' }) 
1928          self.__field_description.writetobuffer(buf) 
1929          try: self.__field_cdate 
1930          except: 
1931              self.__field_cdate=GPSDATE(**{'sizeinbytes': 4,  'default': GPSDATE.now() }) 
1932          self.__field_cdate.writetobuffer(buf) 
1933          try: self.__field_mdate 
1934          except: 
1935              self.__field_mdate=GPSDATE(**{'sizeinbytes': 4,  'default': GPSDATE.now() }) 
1936          self.__field_mdate.writetobuffer(buf) 
1937          try: self.__field_start 
1938          except: 
1939              self.__field_start=LGCALDATE(**{'sizeinbytes': 4,  'default': (0,0,0,0,0) }) 
1940          self.__field_start.writetobuffer(buf) 
1941          try: self.__field_end_time 
1942          except: 
1943              self.__field_end_time=LGCALDATE(**{'sizeinbytes': 4,  'default': (0,0,0,0,0) }) 
1944          self.__field_end_time.writetobuffer(buf) 
1945          try: self.__field_end_date 
1946          except: 
1947              self.__field_end_date=LGCALDATE(**{'sizeinbytes': 4,  'default': (0,0,0,0,0) }) 
1948          self.__field_end_date.writetobuffer(buf) 
1949          try: self.__field_repeat 
1950          except: 
1951              self.__field_repeat=LGCALREPEAT(**{'sizeinbytes': 4,  'default': (0,0,0,0,0) }) 
1952          self.__field_repeat.writetobuffer(buf) 
1953          try: self.__field_alarmindex_vibrate 
1954          except: 
1955              self.__field_alarmindex_vibrate=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
1956          self.__field_alarmindex_vibrate.writetobuffer(buf) 
1957          try: self.__field_ringtone 
1958          except: 
1959              self.__field_ringtone=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
1960          self.__field_ringtone.writetobuffer(buf) 
1961          try: self.__field_unknown1 
1962          except: 
1963              self.__field_unknown1=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
1964          self.__field_unknown1.writetobuffer(buf) 
1965          try: self.__field_alarmminutes 
1966          except: 
1967              self.__field_alarmminutes=UINT(**{'sizeinbytes': 1,  'default': 0xff }) 
1968          self.__field_alarmminutes.writetobuffer(buf) 
1969          try: self.__field_alarmhours 
1970          except: 
1971              self.__field_alarmhours=UINT(**{'sizeinbytes': 1,  'default': 0xff }) 
1972          self.__field_alarmhours.writetobuffer(buf) 
1973          try: self.__field_unknown2 
1974          except: 
1975              self.__field_unknown2=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
1976          self.__field_unknown2.writetobuffer(buf) 
1977          try: self.__field_unknown3 
1978          except: 
1979              self.__field_unknown3=UINT(**{'sizeinbytes': 2,  'default': 0x01FB }) 
1980          self.__field_unknown3.writetobuffer(buf) 
1981          try: self.__field_unknown4 
1982          except: 
1983              self.__field_unknown4=UINT(**{'sizeinbytes': 4,  'default': 0 }) 
1984          self.__field_unknown4.writetobuffer(buf) 
1985          try: self.__field_serial_number 
1986          except: 
1987              self.__field_serial_number=USTRING(**{'sizeinbytes': 65,  'default': '000000ca-00000000-0000000000-VX855V01', 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False }) 
1988          self.__field_serial_number.writetobuffer(buf) 
1989          self._bufferendoffset=buf.getcurrentoffset() 
1990          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1991   
1992   
1993 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1994          'Reads this packet from the supplied buffer' 
1995          self._bufferstartoffset=buf.getcurrentoffset() 
1996          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1997          self.__field_pos=UINT(**{'sizeinbytes': 4,  'default': 0 }) 
1998          self.__field_pos.readfrombuffer(buf) 
1999          self.__field_description=USTRING(**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' }) 
2000          self.__field_description.readfrombuffer(buf) 
2001          self.__field_cdate=GPSDATE(**{'sizeinbytes': 4,  'default': GPSDATE.now() }) 
2002          self.__field_cdate.readfrombuffer(buf) 
2003          self.__field_mdate=GPSDATE(**{'sizeinbytes': 4,  'default': GPSDATE.now() }) 
2004          self.__field_mdate.readfrombuffer(buf) 
2005          self.__field_start=LGCALDATE(**{'sizeinbytes': 4,  'default': (0,0,0,0,0) }) 
2006          self.__field_start.readfrombuffer(buf) 
2007          self.__field_end_time=LGCALDATE(**{'sizeinbytes': 4,  'default': (0,0,0,0,0) }) 
2008          self.__field_end_time.readfrombuffer(buf) 
2009          self.__field_end_date=LGCALDATE(**{'sizeinbytes': 4,  'default': (0,0,0,0,0) }) 
2010          self.__field_end_date.readfrombuffer(buf) 
2011          self.__field_repeat=LGCALREPEAT(**{'sizeinbytes': 4,  'default': (0,0,0,0,0) }) 
2012          self.__field_repeat.readfrombuffer(buf) 
2013          self.__field_alarmindex_vibrate=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
2014          self.__field_alarmindex_vibrate.readfrombuffer(buf) 
2015          self.__field_ringtone=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
2016          self.__field_ringtone.readfrombuffer(buf) 
2017          self.__field_unknown1=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
2018          self.__field_unknown1.readfrombuffer(buf) 
2019          self.__field_alarmminutes=UINT(**{'sizeinbytes': 1,  'default': 0xff }) 
2020          self.__field_alarmminutes.readfrombuffer(buf) 
2021          self.__field_alarmhours=UINT(**{'sizeinbytes': 1,  'default': 0xff }) 
2022          self.__field_alarmhours.readfrombuffer(buf) 
2023          self.__field_unknown2=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
2024          self.__field_unknown2.readfrombuffer(buf) 
2025          self.__field_unknown3=UINT(**{'sizeinbytes': 2,  'default': 0x01FB }) 
2026          self.__field_unknown3.readfrombuffer(buf) 
2027          self.__field_unknown4=UINT(**{'sizeinbytes': 4,  'default': 0 }) 
2028          self.__field_unknown4.readfrombuffer(buf) 
2029          self.__field_serial_number=USTRING(**{'sizeinbytes': 65,  'default': '000000ca-00000000-0000000000-VX855V01', 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False }) 
2030          self.__field_serial_number.readfrombuffer(buf) 
2031          self._bufferendoffset=buf.getcurrentoffset() 
2032   
2033   
2034 -    def __getfield_packet_size(self): 
2035          return self.__field_packet_size.getvalue() 
2036   
2037 -    def __setfield_packet_size(self, value): 
2038          if isinstance(value,UINT): 
2039              self.__field_packet_size=value 
2040          else: 
2041              self.__field_packet_size=UINT(value,**{ 'constant': 138 }) 
2042   
2043 -    def __delfield_packet_size(self): del self.__field_packet_size 
2044   
2045      packet_size=property(__getfield_packet_size, __setfield_packet_size, __delfield_packet_size, None) 
2046   
2047 -    def __getfield_pos(self): 
2048          try: self.__field_pos 
2049          except: 
2050              self.__field_pos=UINT(**{'sizeinbytes': 4,  'default': 0 }) 
2051          return self.__field_pos.getvalue() 
2052   
2053 -    def __setfield_pos(self, value): 
2054          if isinstance(value,UINT): 
2055              self.__field_pos=value 
2056          else: 
2057              self.__field_pos=UINT(value,**{'sizeinbytes': 4,  'default': 0 }) 
2058   
2059 -    def __delfield_pos(self): del self.__field_pos 
2060   
2061      pos=property(__getfield_pos, __setfield_pos, __delfield_pos, "position within file, used as an event id") 
2062   
2063 -    def __getfield_description(self): 
2064          try: self.__field_description 
2065          except: 
2066              self.__field_description=USTRING(**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' }) 
2067          return self.__field_description.getvalue() 
2068   
2069 -    def __setfield_description(self, value): 
2070          if isinstance(value,USTRING): 
2071              self.__field_description=value 
2072          else: 
2073              self.__field_description=USTRING(value,**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' }) 
2074   
2075 -    def __delfield_description(self): del self.__field_description 
2076   
2077      description=property(__getfield_description, __setfield_description, __delfield_description, None) 
2078   
2079 -    def __getfield_cdate(self): 
2080          try: self.__field_cdate 
2081          except: 
2082              self.__field_cdate=GPSDATE(**{'sizeinbytes': 4,  'default': GPSDATE.now() }) 
2083          return self.__field_cdate.getvalue() 
2084   
2085 -    def __setfield_cdate(self, value): 
2086          if isinstance(value,GPSDATE): 
2087              self.__field_cdate=value 
2088          else: 
2089              self.__field_cdate=GPSDATE(value,**{'sizeinbytes': 4,  'default': GPSDATE.now() }) 
2090   
2091 -    def __delfield_cdate(self): del self.__field_cdate 
2092   
2093      cdate=property(__getfield_cdate, __setfield_cdate, __delfield_cdate, None) 
2094   
2095 -    def __getfield_mdate(self): 
2096          try: self.__field_mdate 
2097          except: 
2098              self.__field_mdate=GPSDATE(**{'sizeinbytes': 4,  'default': GPSDATE.now() }) 
2099          return self.__field_mdate.getvalue() 
2100   
2101 -    def __setfield_mdate(self, value): 
2102          if isinstance(value,GPSDATE): 
2103              self.__field_mdate=value 
2104          else: 
2105              self.__field_mdate=GPSDATE(value,**{'sizeinbytes': 4,  'default': GPSDATE.now() }) 
2106   
2107 -    def __delfield_mdate(self): del self.__field_mdate 
2108   
2109      mdate=property(__getfield_mdate, __setfield_mdate, __delfield_mdate, None) 
2110   
2111 -    def __getfield_start(self): 
2112          try: self.__field_start 
2113          except: 
2114              self.__field_start=LGCALDATE(**{'sizeinbytes': 4,  'default': (0,0,0,0,0) }) 
2115          return self.__field_start.getvalue() 
2116   
2117 -    def __setfield_start(self, value): 
2118          if isinstance(value,LGCALDATE): 
2119              self.__field_start=value 
2120          else: 
2121              self.__field_start=LGCALDATE(value,**{'sizeinbytes': 4,  'default': (0,0,0,0,0) }) 
2122   
2123 -    def __delfield_start(self): del self.__field_start 
2124   
2125      start=property(__getfield_start, __setfield_start, __delfield_start, None) 
2126   
2127 -    def __getfield_end_time(self): 
2128          try: self.__field_end_time 
2129          except: 
2130              self.__field_end_time=LGCALDATE(**{'sizeinbytes': 4,  'default': (0,0,0,0,0) }) 
2131          return self.__field_end_time.getvalue() 
2132   
2133 -    def __setfield_end_time(self, value): 
2134          if isinstance(value,LGCALDATE): 
2135              self.__field_end_time=value 
2136          else: 
2137              self.__field_end_time=LGCALDATE(value,**{'sizeinbytes': 4,  'default': (0,0,0,0,0) }) 
2138   
2139 -    def __delfield_end_time(self): del self.__field_end_time 
2140   
2141      end_time=property(__getfield_end_time, __setfield_end_time, __delfield_end_time, None) 
2142   
2143 -    def __getfield_end_date(self): 
2144          try: self.__field_end_date 
2145          except: 
2146              self.__field_end_date=LGCALDATE(**{'sizeinbytes': 4,  'default': (0,0,0,0,0) }) 
2147          return self.__field_end_date.getvalue() 
2148   
2149 -    def __setfield_end_date(self, value): 
2150          if isinstance(value,LGCALDATE): 
2151              self.__field_end_date=value 
2152          else: 
2153              self.__field_end_date=LGCALDATE(value,**{'sizeinbytes': 4,  'default': (0,0,0,0,0) }) 
2154   
2155 -    def __delfield_end_date(self): del self.__field_end_date 
2156   
2157      end_date=property(__getfield_end_date, __setfield_end_date, __delfield_end_date, None) 
2158   
2159 -    def __getfield_repeat(self): 
2160          try: self.__field_repeat 
2161          except: 
2162              self.__field_repeat=LGCALREPEAT(**{'sizeinbytes': 4,  'default': (0,0,0,0,0) }) 
2163          return self.__field_repeat.getvalue() 
2164   
2165 -    def __setfield_repeat(self, value): 
2166          if isinstance(value,LGCALREPEAT): 
2167              self.__field_repeat=value 
2168          else: 
2169              self.__field_repeat=LGCALREPEAT(value,**{'sizeinbytes': 4,  'default': (0,0,0,0,0) }) 
2170   
2171 -    def __delfield_repeat(self): del self.__field_repeat 
2172   
2173      repeat=property(__getfield_repeat, __setfield_repeat, __delfield_repeat, None) 
2174   
2175 -    def __getfield_alarmindex_vibrate(self): 
2176          try: self.__field_alarmindex_vibrate 
2177          except: 
2178              self.__field_alarmindex_vibrate=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
2179          return self.__field_alarmindex_vibrate.getvalue() 
2180   
2181 -    def __setfield_alarmindex_vibrate(self, value): 
2182          if isinstance(value,UINT): 
2183              self.__field_alarmindex_vibrate=value 
2184          else: 
2185              self.__field_alarmindex_vibrate=UINT(value,**{'sizeinbytes': 1,  'default': 0 }) 
2186   
2187 -    def __delfield_alarmindex_vibrate(self): del self.__field_alarmindex_vibrate 
2188   
2189      alarmindex_vibrate=property(__getfield_alarmindex_vibrate, __setfield_alarmindex_vibrate, __delfield_alarmindex_vibrate, None) 
2190   
2191 -    def __getfield_ringtone(self): 
2192          try: self.__field_ringtone 
2193          except: 
2194              self.__field_ringtone=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
2195          return self.__field_ringtone.getvalue() 
2196   
2197 -    def __setfield_ringtone(self, value): 
2198          if isinstance(value,UINT): 
2199              self.__field_ringtone=value 
2200          else: 
2201              self.__field_ringtone=UINT(value,**{'sizeinbytes': 1,  'default': 0 }) 
2202   
2203 -    def __delfield_ringtone(self): del self.__field_ringtone 
2204   
2205      ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 
2206   
2207 -    def __getfield_unknown1(self): 
2208          try: self.__field_unknown1 
2209          except: 
2210              self.__field_unknown1=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
2211          return self.__field_unknown1.getvalue() 
2212   
2213 -    def __setfield_unknown1(self, value): 
2214          if isinstance(value,UINT): 
2215              self.__field_unknown1=value 
2216          else: 
2217              self.__field_unknown1=UINT(value,**{'sizeinbytes': 1,  'default': 0 }) 
2218   
2219 -    def __delfield_unknown1(self): del self.__field_unknown1 
2220   
2221      unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 
2222   
2223 -    def __getfield_alarmminutes(self): 
2224          try: self.__field_alarmminutes 
2225          except: 
2226              self.__field_alarmminutes=UINT(**{'sizeinbytes': 1,  'default': 0xff }) 
2227          return self.__field_alarmminutes.getvalue() 
2228   
2229 -    def __setfield_alarmminutes(self, value): 
2230          if isinstance(value,UINT): 
2231              self.__field_alarmminutes=value 
2232          else: 
2233              self.__field_alarmminutes=UINT(value,**{'sizeinbytes': 1,  'default': 0xff }) 
2234   
2235 -    def __delfield_alarmminutes(self): del self.__field_alarmminutes 
2236   
2237      alarmminutes=property(__getfield_alarmminutes, __setfield_alarmminutes, __delfield_alarmminutes, "a value of 0xFF indicates not set") 
2238   
2239 -    def __getfield_alarmhours(self): 
2240          try: self.__field_alarmhours 
2241          except: 
2242              self.__field_alarmhours=UINT(**{'sizeinbytes': 1,  'default': 0xff }) 
2243          return self.__field_alarmhours.getvalue() 
2244   
2245 -    def __setfield_alarmhours(self, value): 
2246          if isinstance(value,UINT): 
2247              self.__field_alarmhours=value 
2248          else: 
2249              self.__field_alarmhours=UINT(value,**{'sizeinbytes': 1,  'default': 0xff }) 
2250   
2251 -    def __delfield_alarmhours(self): del self.__field_alarmhours 
2252   
2253      alarmhours=property(__getfield_alarmhours, __setfield_alarmhours, __delfield_alarmhours, "a value of 0xFF indicates not set") 
2254   
2255 -    def __getfield_unknown2(self): 
2256          try: self.__field_unknown2 
2257          except: 
2258              self.__field_unknown2=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
2259          return self.__field_unknown2.getvalue() 
2260   
2261 -    def __setfield_unknown2(self, value): 
2262          if isinstance(value,UINT): 
2263              self.__field_unknown2=value 
2264          else: 
2265              self.__field_unknown2=UINT(value,**{'sizeinbytes': 1,  'default': 0 }) 
2266   
2267 -    def __delfield_unknown2(self): del self.__field_unknown2 
2268   
2269      unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None) 
2270   
2271 -    def __getfield_unknown3(self): 
2272          try: self.__field_unknown3 
2273          except: 
2274              self.__field_unknown3=UINT(**{'sizeinbytes': 2,  'default': 0x01FB }) 
2275          return self.__field_unknown3.getvalue() 
2276   
2277 -    def __setfield_unknown3(self, value): 
2278          if isinstance(value,UINT): 
2279              self.__field_unknown3=value 
2280          else: 
2281              self.__field_unknown3=UINT(value,**{'sizeinbytes': 2,  'default': 0x01FB }) 
2282   
2283 -    def __delfield_unknown3(self): del self.__field_unknown3 
2284   
2285      unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None) 
2286   
2287 -    def __getfield_unknown4(self): 
2288          try: self.__field_unknown4 
2289          except: 
2290              self.__field_unknown4=UINT(**{'sizeinbytes': 4,  'default': 0 }) 
2291          return self.__field_unknown4.getvalue() 
2292   
2293 -    def __setfield_unknown4(self, value): 
2294          if isinstance(value,UINT): 
2295              self.__field_unknown4=value 
2296          else: 
2297              self.__field_unknown4=UINT(value,**{'sizeinbytes': 4,  'default': 0 }) 
2298   
2299 -    def __delfield_unknown4(self): del self.__field_unknown4 
2300   
2301      unknown4=property(__getfield_unknown4, __setfield_unknown4, __delfield_unknown4, None) 
2302   
2303 -    def __getfield_serial_number(self): 
2304          try: self.__field_serial_number 
2305          except: 
2306              self.__field_serial_number=USTRING(**{'sizeinbytes': 65,  'default': '000000ca-00000000-0000000000-VX855V01', 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False }) 
2307          return self.__field_serial_number.getvalue() 
2308   
2309 -    def __setfield_serial_number(self, value): 
2310          if isinstance(value,USTRING): 
2311              self.__field_serial_number=value 
2312          else: 
2313              self.__field_serial_number=USTRING(value,**{'sizeinbytes': 65,  'default': '000000ca-00000000-0000000000-VX855V01', 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False }) 
2314   
2315 -    def __delfield_serial_number(self): del self.__field_serial_number 
2316   
2317      serial_number=property(__getfield_serial_number, __setfield_serial_number, __delfield_serial_number, None) 
2318   
2319 -    def iscontainer(self): 
2320          return True 
2321   
2322 -    def containerelements(self): 
2323          yield ('packet_size', self.__field_packet_size, None) 
2324          yield ('pos', self.__field_pos, "position within file, used as an event id") 
2325          yield ('description', self.__field_description, None) 
2326          yield ('cdate', self.__field_cdate, None) 
2327          yield ('mdate', self.__field_mdate, None) 
2328          yield ('start', self.__field_start, None) 
2329          yield ('end_time', self.__field_end_time, None) 
2330          yield ('end_date', self.__field_end_date, None) 
2331          yield ('repeat', self.__field_repeat, None) 
2332          yield ('alarmindex_vibrate', self.__field_alarmindex_vibrate, None) 
2333          yield ('ringtone', self.__field_ringtone, None) 
2334          yield ('unknown1', self.__field_unknown1, None) 
2335          yield ('alarmminutes', self.__field_alarmminutes, "a value of 0xFF indicates not set") 
2336          yield ('alarmhours', self.__field_alarmhours, "a value of 0xFF indicates not set") 
2337          yield ('unknown2', self.__field_unknown2, None) 
2338          yield ('unknown3', self.__field_unknown3, None) 
2339          yield ('unknown4', self.__field_unknown4, None) 
2340          yield ('serial_number', self.__field_serial_number, None) 
2341   
2342   
2343   
2344   
2345 -class schedulefile(BaseProtogenClass): 
2346      __fields=['numactiveitems', 'events'] 
2347   
2348 -    def __init__(self, *args, **kwargs): 
2349          dict={} 
2350          # What was supplied to this function 
2351          dict.update(kwargs) 
2352          # Parent constructor 
2353          super(schedulefile,self).__init__(**dict) 
2354          if self.__class__ is schedulefile: 
2355              self._update(args,dict) 
2356   
2357   
2358 -    def getfields(self): 
2359          return self.__fields 
2360   
2361   
2362 -    def _update(self, args, kwargs): 
2363          super(schedulefile,self)._update(args,kwargs) 
2364          keys=kwargs.keys() 
2365          for key in keys: 
2366              if key in self.__fields: 
2367                  setattr(self, key, kwargs[key]) 
2368                  del kwargs[key] 
2369          # Were any unrecognized kwargs passed in? 
2370          if __debug__: 
2371              self._complainaboutunusedargs(schedulefile,kwargs) 
2372          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2373          # Make all P fields that haven't already been constructed 
2374   
2375   
2376 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2377          'Writes this packet to the supplied buffer' 
2378          self._bufferstartoffset=buf.getcurrentoffset() 
2379          self.__field_numactiveitems.writetobuffer(buf) 
2380          try: self.__field_events 
2381          except: 
2382              self.__field_events=LIST(**{ 'elementclass': scheduleevent, 'length': NUMCALENDARENTRIES, 'createdefault': True }) 
2383          self.__field_events.writetobuffer(buf) 
2384          self._bufferendoffset=buf.getcurrentoffset() 
2385          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2386   
2387   
2388 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2389          'Reads this packet from the supplied buffer' 
2390          self._bufferstartoffset=buf.getcurrentoffset() 
2391          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2392          self.__field_numactiveitems=UINT(**{'sizeinbytes': 2}) 
2393          self.__field_numactiveitems.readfrombuffer(buf) 
2394          self.__field_events=LIST(**{ 'elementclass': scheduleevent, 'length': NUMCALENDARENTRIES, 'createdefault': True }) 
2395          self.__field_events.readfrombuffer(buf) 
2396          self._bufferendoffset=buf.getcurrentoffset() 
2397   
2398   
2399 -    def __getfield_numactiveitems(self): 
2400          return self.__field_numactiveitems.getvalue() 
2401   
2402 -    def __setfield_numactiveitems(self, value): 
2403          if isinstance(value,UINT): 
2404              self.__field_numactiveitems=value 
2405          else: 
2406              self.__field_numactiveitems=UINT(value,**{'sizeinbytes': 2}) 
2407   
2408 -    def __delfield_numactiveitems(self): del self.__field_numactiveitems 
2409   
2410      numactiveitems=property(__getfield_numactiveitems, __setfield_numactiveitems, __delfield_numactiveitems, None) 
2411   
2412 -    def __getfield_events(self): 
2413          try: self.__field_events 
2414          except: 
2415              self.__field_events=LIST(**{ 'elementclass': scheduleevent, 'length': NUMCALENDARENTRIES, 'createdefault': True }) 
2416          return self.__field_events.getvalue() 
2417   
2418 -    def __setfield_events(self, value): 
2419          if isinstance(value,LIST): 
2420              self.__field_events=value 
2421          else: 
2422              self.__field_events=LIST(value,**{ 'elementclass': scheduleevent, 'length': NUMCALENDARENTRIES, 'createdefault': True }) 
2423   
2424 -    def __delfield_events(self): del self.__field_events 
2425   
2426      events=property(__getfield_events, __setfield_events, __delfield_events, None) 
2427   
2428 -    def iscontainer(self): 
2429          return True 
2430   
2431 -    def containerelements(self): 
2432          yield ('numactiveitems', self.__field_numactiveitems, None) 
2433          yield ('events', self.__field_events, None) 
2434   
2435   
2436   
2437   
2438 -class scheduleringerfile(BaseProtogenClass): 
2439      __fields=['numringers', 'ringerpaths'] 
2440   
2441 -    def __init__(self, *args, **kwargs): 
2442          dict={} 
2443          # What was supplied to this function 
2444          dict.update(kwargs) 
2445          # Parent constructor 
2446          super(scheduleringerfile,self).__init__(**dict) 
2447          if self.__class__ is scheduleringerfile: 
2448              self._update(args,dict) 
2449   
2450   
2451 -    def getfields(self): 
2452          return self.__fields 
2453   
2454   
2455 -    def _update(self, args, kwargs): 
2456          super(scheduleringerfile,self)._update(args,kwargs) 
2457          keys=kwargs.keys() 
2458          for key in keys: 
2459              if key in self.__fields: 
2460                  setattr(self, key, kwargs[key]) 
2461                  del kwargs[key] 
2462          # Were any unrecognized kwargs passed in? 
2463          if __debug__: 
2464              self._complainaboutunusedargs(scheduleringerfile,kwargs) 
2465          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2466          # Make all P fields that haven't already been constructed 
2467   
2468   
2469 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2470          'Writes this packet to the supplied buffer' 
2471          self._bufferstartoffset=buf.getcurrentoffset() 
2472          self.__field_numringers.writetobuffer(buf) 
2473          try: self.__field_ringerpaths 
2474          except: 
2475              self.__field_ringerpaths=LIST(**{'elementclass': _gen_p_lgvx8550_205}) 
2476          self.__field_ringerpaths.writetobuffer(buf) 
2477          self._bufferendoffset=buf.getcurrentoffset() 
2478          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2479   
2480   
2481 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2482          'Reads this packet from the supplied buffer' 
2483          self._bufferstartoffset=buf.getcurrentoffset() 
2484          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2485          self.__field_numringers=UINT(**{'sizeinbytes': 4}) 
2486          self.__field_numringers.readfrombuffer(buf) 
2487          self.__field_ringerpaths=LIST(**{'elementclass': _gen_p_lgvx8550_205}) 
2488          self.__field_ringerpaths.readfrombuffer(buf) 
2489          self._bufferendoffset=buf.getcurrentoffset() 
2490   
2491   
2492 -    def __getfield_numringers(self): 
2493          return self.__field_numringers.getvalue() 
2494   
2495 -    def __setfield_numringers(self, value): 
2496          if isinstance(value,UINT): 
2497              self.__field_numringers=value 
2498          else: 
2499              self.__field_numringers=UINT(value,**{'sizeinbytes': 4}) 
2500   
2501 -    def __delfield_numringers(self): del self.__field_numringers 
2502   
2503      numringers=property(__getfield_numringers, __setfield_numringers, __delfield_numringers, None) 
2504   
2505 -    def __getfield_ringerpaths(self): 
2506          try: self.__field_ringerpaths 
2507          except: 
2508              self.__field_ringerpaths=LIST(**{'elementclass': _gen_p_lgvx8550_205}) 
2509          return self.__field_ringerpaths.getvalue() 
2510   
2511 -    def __setfield_ringerpaths(self, value): 
2512          if isinstance(value,LIST): 
2513              self.__field_ringerpaths=value 
2514          else: 
2515              self.__field_ringerpaths=LIST(value,**{'elementclass': _gen_p_lgvx8550_205}) 
2516   
2517 -    def __delfield_ringerpaths(self): del self.__field_ringerpaths 
2518   
2519      ringerpaths=property(__getfield_ringerpaths, __setfield_ringerpaths, __delfield_ringerpaths, None) 
2520   
2521 -    def iscontainer(self): 
2522          return True 
2523   
2524 -    def containerelements(self): 
2525          yield ('numringers', self.__field_numringers, None) 
2526          yield ('ringerpaths', self.__field_ringerpaths, None) 
2527   
2528   
2529   
2530   
2531 -class _gen_p_lgvx8550_205(BaseProtogenClass): 
2532      'Anonymous inner class' 
2533      __fields=['path'] 
2534   
2535 -    def __init__(self, *args, **kwargs): 
2536          dict={} 
2537          # What was supplied to this function 
2538          dict.update(kwargs) 
2539          # Parent constructor 
2540          super(_gen_p_lgvx8550_205,self).__init__(**dict) 
2541          if self.__class__ is _gen_p_lgvx8550_205: 
2542              self._update(args,dict) 
2543   
2544   
2545 -    def getfields(self): 
2546          return self.__fields 
2547   
2548   
2549 -    def _update(self, args, kwargs): 
2550          super(_gen_p_lgvx8550_205,self)._update(args,kwargs) 
2551          keys=kwargs.keys() 
2552          for key in keys: 
2553              if key in self.__fields: 
2554                  setattr(self, key, kwargs[key]) 
2555                  del kwargs[key] 
2556          # Were any unrecognized kwargs passed in? 
2557          if __debug__: 
2558              self._complainaboutunusedargs(_gen_p_lgvx8550_205,kwargs) 
2559          if len(args): 
2560              dict2={'sizeinbytes': 256,  'encoding': PHONE_ENCODING, 'raiseontruncate': True } 
2561              dict2.update(kwargs) 
2562              kwargs=dict2 
2563              self.__field_path=USTRING(*args,**dict2) 
2564          # Make all P fields that haven't already been constructed 
2565   
2566   
2567 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2568          'Writes this packet to the supplied buffer' 
2569          self._bufferstartoffset=buf.getcurrentoffset() 
2570          self.__field_path.writetobuffer(buf) 
2571          self._bufferendoffset=buf.getcurrentoffset() 
2572          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2573   
2574   
2575 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2576          'Reads this packet from the supplied buffer' 
2577          self._bufferstartoffset=buf.getcurrentoffset() 
2578          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2579          self.__field_path=USTRING(**{'sizeinbytes': 256,  'encoding': PHONE_ENCODING, 'raiseontruncate': True }) 
2580          self.__field_path.readfrombuffer(buf) 
2581          self._bufferendoffset=buf.getcurrentoffset() 
2582   
2583   
2584 -    def __getfield_path(self): 
2585          return self.__field_path.getvalue() 
2586   
2587 -    def __setfield_path(self, value): 
2588          if isinstance(value,USTRING): 
2589              self.__field_path=value 
2590          else: 
2591              self.__field_path=USTRING(value,**{'sizeinbytes': 256,  'encoding': PHONE_ENCODING, 'raiseontruncate': True }) 
2592   
2593 -    def __delfield_path(self): del self.__field_path 
2594   
2595      path=property(__getfield_path, __setfield_path, __delfield_path, None) 
2596   
2597 -    def iscontainer(self): 
2598          return True 
2599   
2600 -    def containerelements(self): 
2601          yield ('path', self.__field_path, None) 
2602   
2603   
2604   
2605   
2606 -class textmemo(BaseProtogenClass): 
2607      __fields=['cdate', 'text', 'memotime', 'zeros'] 
2608   
2609 -    def __init__(self, *args, **kwargs): 
2610          dict={} 
2611          # What was supplied to this function 
2612          dict.update(kwargs) 
2613          # Parent constructor 
2614          super(textmemo,self).__init__(**dict) 
2615          if self.__class__ is textmemo: 
2616              self._update(args,dict) 
2617   
2618   
2619 -    def getfields(self): 
2620          return self.__fields 
2621   
2622   
2623 -    def _update(self, args, kwargs): 
2624          super(textmemo,self)._update(args,kwargs) 
2625          keys=kwargs.keys() 
2626          for key in keys: 
2627              if key in self.__fields: 
2628                  setattr(self, key, kwargs[key]) 
2629                  del kwargs[key] 
2630          # Were any unrecognized kwargs passed in? 
2631          if __debug__: 
2632              self._complainaboutunusedargs(textmemo,kwargs) 
2633          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2634          # Make all P fields that haven't already been constructed 
2635   
2636   
2637 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2638          'Writes this packet to the supplied buffer' 
2639          self._bufferstartoffset=buf.getcurrentoffset() 
2640          try: self.__field_cdate 
2641          except: 
2642              self.__field_cdate=GPSDATE(**{'sizeinbytes': 4,  'default': GPSDATE.now(),                'unique': True }) 
2643          self.__field_cdate.writetobuffer(buf) 
2644          self.__field_text.writetobuffer(buf) 
2645          self.__field_memotime.writetobuffer(buf) 
2646          try: self.__field_zeros 
2647          except: 
2648              self.__field_zeros=UNKNOWN(**{'sizeinbytes': 3}) 
2649          self.__field_zeros.writetobuffer(buf) 
2650          self._bufferendoffset=buf.getcurrentoffset() 
2651          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2652   
2653   
2654 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2655          'Reads this packet from the supplied buffer' 
2656          self._bufferstartoffset=buf.getcurrentoffset() 
2657          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2658          self.__field_cdate=GPSDATE(**{'sizeinbytes': 4,  'default': GPSDATE.now(),                'unique': True }) 
2659          self.__field_cdate.readfrombuffer(buf) 
2660          self.__field_text=USTRING(**{'sizeinbytes': 301, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False }) 
2661          self.__field_text.readfrombuffer(buf) 
2662          self.__field_memotime=LGCALDATE(**{'sizeinbytes': 4}) 
2663          self.__field_memotime.readfrombuffer(buf) 
2664          self.__field_zeros=UNKNOWN(**{'sizeinbytes': 3}) 
2665          self.__field_zeros.readfrombuffer(buf) 
2666          self._bufferendoffset=buf.getcurrentoffset() 
2667   
2668   
2669 -    def __getfield_cdate(self): 
2670          try: self.__field_cdate 
2671          except: 
2672              self.__field_cdate=GPSDATE(**{'sizeinbytes': 4,  'default': GPSDATE.now(),                'unique': True }) 
2673          return self.__field_cdate.getvalue() 
2674   
2675 -    def __setfield_cdate(self, value): 
2676          if isinstance(value,GPSDATE): 
2677              self.__field_cdate=value 
2678          else: 
2679              self.__field_cdate=GPSDATE(value,**{'sizeinbytes': 4,  'default': GPSDATE.now(),                'unique': True }) 
2680   
2681 -    def __delfield_cdate(self): del self.__field_cdate 
2682   
2683      cdate=property(__getfield_cdate, __setfield_cdate, __delfield_cdate, None) 
2684   
2685 -    def __getfield_text(self): 
2686          return self.__field_text.getvalue() 
2687   
2688 -    def __setfield_text(self, value): 
2689          if isinstance(value,USTRING): 
2690              self.__field_text=value 
2691          else: 
2692              self.__field_text=USTRING(value,**{'sizeinbytes': 301, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False }) 
2693   
2694 -    def __delfield_text(self): del self.__field_text 
2695   
2696      text=property(__getfield_text, __setfield_text, __delfield_text, None) 
2697   
2698 -    def __getfield_memotime(self): 
2699          return self.__field_memotime.getvalue() 
2700   
2701 -    def __setfield_memotime(self, value): 
2702          if isinstance(value,LGCALDATE): 
2703              self.__field_memotime=value 
2704          else: 
2705              self.__field_memotime=LGCALDATE(value,**{'sizeinbytes': 4}) 
2706   
2707 -    def __delfield_memotime(self): del self.__field_memotime 
2708   
2709      memotime=property(__getfield_memotime, __setfield_memotime, __delfield_memotime, None) 
2710   
2711 -    def __getfield_zeros(self): 
2712          try: self.__field_zeros 
2713          except: 
2714              self.__field_zeros=UNKNOWN(**{'sizeinbytes': 3}) 
2715          return self.__field_zeros.getvalue() 
2716   
2717 -    def __setfield_zeros(self, value): 
2718          if isinstance(value,UNKNOWN): 
2719              self.__field_zeros=value 
2720          else: 
2721              self.__field_zeros=UNKNOWN(value,**{'sizeinbytes': 3}) 
2722   
2723 -    def __delfield_zeros(self): del self.__field_zeros 
2724   
2725      zeros=property(__getfield_zeros, __setfield_zeros, __delfield_zeros, None) 
2726   
2727 -    def iscontainer(self): 
2728          return True 
2729   
2730 -    def containerelements(self): 
2731          yield ('cdate', self.__field_cdate, None) 
2732          yield ('text', self.__field_text, None) 
2733          yield ('memotime', self.__field_memotime, None) 
2734          yield ('zeros', self.__field_zeros, None) 
2735   
2736   
2737   
2738   
2739 -class textmemofile(BaseProtogenClass): 
2740      __fields=['itemcount', 'items'] 
2741   
2742 -    def __init__(self, *args, **kwargs): 
2743          dict={} 
2744          # What was supplied to this function 
2745          dict.update(kwargs) 
2746          # Parent constructor 
2747          super(textmemofile,self).__init__(**dict) 
2748          if self.__class__ is textmemofile: 
2749              self._update(args,dict) 
2750   
2751   
2752 -    def getfields(self): 
2753          return self.__fields 
2754   
2755   
2756 -    def _update(self, args, kwargs): 
2757          super(textmemofile,self)._update(args,kwargs) 
2758          keys=kwargs.keys() 
2759          for key in keys: 
2760              if key in self.__fields: 
2761                  setattr(self, key, kwargs[key]) 
2762                  del kwargs[key] 
2763          # Were any unrecognized kwargs passed in? 
2764          if __debug__: 
2765              self._complainaboutunusedargs(textmemofile,kwargs) 
2766          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2767          # Make all P fields that haven't already been constructed 
2768   
2769   
2770 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2771          'Writes this packet to the supplied buffer' 
2772          self._bufferstartoffset=buf.getcurrentoffset() 
2773          self.__field_itemcount.writetobuffer(buf) 
2774          try: self.__field_items 
2775          except: 
2776              self.__field_items=LIST(**{ 'elementclass': textmemo }) 
2777          self.__field_items.writetobuffer(buf) 
2778          self._bufferendoffset=buf.getcurrentoffset() 
2779          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2780   
2781   
2782 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2783          'Reads this packet from the supplied buffer' 
2784          self._bufferstartoffset=buf.getcurrentoffset() 
2785          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2786          self.__field_itemcount=UINT(**{'sizeinbytes': 4}) 
2787          self.__field_itemcount.readfrombuffer(buf) 
2788          self.__field_items=LIST(**{ 'elementclass': textmemo }) 
2789          self.__field_items.readfrombuffer(buf) 
2790          self._bufferendoffset=buf.getcurrentoffset() 
2791   
2792   
2793 -    def __getfield_itemcount(self): 
2794          return self.__field_itemcount.getvalue() 
2795   
2796 -    def __setfield_itemcount(self, value): 
2797          if isinstance(value,UINT): 
2798              self.__field_itemcount=value 
2799          else: 
2800              self.__field_itemcount=UINT(value,**{'sizeinbytes': 4}) 
2801   
2802 -    def __delfield_itemcount(self): del self.__field_itemcount 
2803   
2804      itemcount=property(__getfield_itemcount, __setfield_itemcount, __delfield_itemcount, None) 
2805   
2806 -    def __getfield_items(self): 
2807          try: self.__field_items 
2808          except: 
2809              self.__field_items=LIST(**{ 'elementclass': textmemo }) 
2810          return self.__field_items.getvalue() 
2811   
2812 -    def __setfield_items(self, value): 
2813          if isinstance(value,LIST): 
2814              self.__field_items=value 
2815          else: 
2816              self.__field_items=LIST(value,**{ 'elementclass': textmemo }) 
2817   
2818 -    def __delfield_items(self): del self.__field_items 
2819   
2820      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
2821   
2822 -    def iscontainer(self): 
2823          return True 
2824   
2825 -    def containerelements(self): 
2826          yield ('itemcount', self.__field_itemcount, None) 
2827          yield ('items', self.__field_items, None) 
2828