Source Code for Module phones.p_lgvx11000

   1  # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE 
   2   
   3  """Various descriptions of data specific to LG VX11000""" 
   4   
   5  # groups     - same as VX-8700 (added group wallpaper bit) 
   6  # phonebook  - LG Phonebook v1.0 (same as VX-8550) 
   7  # schedule   - same as VX-8550 
   8  # memos      - same as VX-8550 
   9  # sms        - same as VX-9100 
  10  # index file - same as VX-9700 
  11  # favorites  - same as VX-9600 
  12  from p_lgvx9600 import * 
  13   
  14  # SMS index files 
  15  inbox_index     = "dload/inbox.dat" 
  16  outbox_index    = "dload/outbox.dat" 
  17  drafts_index    = "dload/drafts.dat" 
  18   
  19  # Phonebook addresses 
  20  pa_file_name = "pim/pbaddress.dat" 
  21  pb_group_filename = "pim/pbgroup.dat" 
  22   
  23  #Group Picture ID Path Index File 
  24  GroupWPPathIndexFile='pim/pbGroupPixIdSetAsPath.dat' 
  25   
  26  # Phonebook favorites 
  27  favorites_file_name  = "pim/pbFavorite.dat" 
  28  NUMFAVORITES=10 
  29   
  30  #verified these constants specific to VX11000 
  31  PHONEBOOKENTRYSIZE=512 
  32  NUMSPEEDDIALS=1000 
  33  FIRSTSPEEDDIAL=1 
  34  LASTSPEEDDIAL=999 
  35  NUMEMERGENCYCONTACTS=3 
  36  NUMPHONEBOOKENTRIES=1000 
  37  NUMEMAILS=2 
  38  NUMPHONENUMBERS=5 
  39  MAXCALENDARDESCRIPTION=32 
  40  MAX_PHONEBOOK_GROUPS=30 
  41  MEMOLENGTH=300 
  42  SMS_CANNED_MAX_ITEMS=30 
  43  SMS_CANNED_MAX_LENGTH=100 
  44  NUMCALENDARENTRIES=300 #TODO: need to verify this number 
  45   
  46  PA_ENTRY_SOR = "<PA>" 
  47   
  48 -class call(BaseProtogenClass): 
  49      __fields=['GPStime', 'unk0', 'duration', 'number', 'name', 'numberlength', 'status', 'pbnumbertype', 'unk1', 'pbentrynum', 'number_location'] 
  50   
  51 -    def __init__(self, *args, **kwargs): 
  52          dict={} 
  53          # What was supplied to this function 
  54          dict.update(kwargs) 
  55          # Parent constructor 
  56          super(call,self).__init__(**dict) 
  57          if self.__class__ is call: 
  58              self._update(args,dict) 
  59   
  60   
  61 -    def getfields(self): 
  62          return self.__fields 
  63   
  64   
  65 -    def _update(self, args, kwargs): 
  66          super(call,self)._update(args,kwargs) 
  67          keys=kwargs.keys() 
  68          for key in keys: 
  69              if key in self.__fields: 
  70                  setattr(self, key, kwargs[key]) 
  71                  del kwargs[key] 
  72          # Were any unrecognized kwargs passed in? 
  73          if __debug__: 
  74              self._complainaboutunusedargs(call,kwargs) 
  75          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
  76          # Make all P fields that haven't already been constructed 
  77   
  78   
  79 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
  80          'Writes this packet to the supplied buffer' 
  81          self._bufferstartoffset=buf.getcurrentoffset() 
  82          self.__field_GPStime.writetobuffer(buf) 
  83          self.__field_unk0.writetobuffer(buf) 
  84          self.__field_duration.writetobuffer(buf) 
  85          self.__field_number.writetobuffer(buf) 
  86          self.__field_name.writetobuffer(buf) 
  87          self.__field_numberlength.writetobuffer(buf) 
  88          self.__field_status.writetobuffer(buf) 
  89          self.__field_pbnumbertype.writetobuffer(buf) 
  90          self.__field_unk1.writetobuffer(buf) 
  91          self.__field_pbentrynum.writetobuffer(buf) 
  92          self.__field_number_location.writetobuffer(buf) 
  93          self._bufferendoffset=buf.getcurrentoffset() 
  94          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
  95   
  96   
  97 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
  98          'Reads this packet from the supplied buffer' 
  99          self._bufferstartoffset=buf.getcurrentoffset() 
 100          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 101          self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4}) 
 102          self.__field_GPStime.readfrombuffer(buf) 
 103          self.__field_unk0=UINT(**{'sizeinbytes': 4}) 
 104          self.__field_unk0.readfrombuffer(buf) 
 105          self.__field_duration=UINT(**{'sizeinbytes': 4}) 
 106          self.__field_duration.readfrombuffer(buf) 
 107          self.__field_number=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 
 108          self.__field_number.readfrombuffer(buf) 
 109          self.__field_name=USTRING(**{'sizeinbytes': 36, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
 110          self.__field_name.readfrombuffer(buf) 
 111          self.__field_numberlength=UINT(**{'sizeinbytes': 1}) 
 112          self.__field_numberlength.readfrombuffer(buf) 
 113          self.__field_status=UINT(**{'sizeinbytes': 1}) 
 114          self.__field_status.readfrombuffer(buf) 
 115          self.__field_pbnumbertype=UINT(**{'sizeinbytes': 1}) 
 116          self.__field_pbnumbertype.readfrombuffer(buf) 
 117          self.__field_unk1=UINT(**{'sizeinbytes': 4}) 
 118          self.__field_unk1.readfrombuffer(buf) 
 119          self.__field_pbentrynum=UINT(**{'sizeinbytes': 2}) 
 120          self.__field_pbentrynum.readfrombuffer(buf) 
 121          self.__field_number_location=DATA(**{'sizeinbytes': 76}) 
 122          self.__field_number_location.readfrombuffer(buf) 
 123          self._bufferendoffset=buf.getcurrentoffset() 
 124   
 125   
 126 -    def __getfield_GPStime(self): 
 127          return self.__field_GPStime.getvalue() 
 128   
 129 -    def __setfield_GPStime(self, value): 
 130          if isinstance(value,GPSDATE): 
 131              self.__field_GPStime=value 
 132          else: 
 133              self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4}) 
 134   
 135 -    def __delfield_GPStime(self): del self.__field_GPStime 
 136   
 137      GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None) 
 138   
 139 -    def __getfield_unk0(self): 
 140          return self.__field_unk0.getvalue() 
 141   
 142 -    def __setfield_unk0(self, value): 
 143          if isinstance(value,UINT): 
 144              self.__field_unk0=value 
 145          else: 
 146              self.__field_unk0=UINT(value,**{'sizeinbytes': 4}) 
 147   
 148 -    def __delfield_unk0(self): del self.__field_unk0 
 149   
 150      unk0=property(__getfield_unk0, __setfield_unk0, __delfield_unk0, None) 
 151   
 152 -    def __getfield_duration(self): 
 153          return self.__field_duration.getvalue() 
 154   
 155 -    def __setfield_duration(self, value): 
 156          if isinstance(value,UINT): 
 157              self.__field_duration=value 
 158          else: 
 159              self.__field_duration=UINT(value,**{'sizeinbytes': 4}) 
 160   
 161 -    def __delfield_duration(self): del self.__field_duration 
 162   
 163      duration=property(__getfield_duration, __setfield_duration, __delfield_duration, None) 
 164   
 165 -    def __getfield_number(self): 
 166          return self.__field_number.getvalue() 
 167   
 168 -    def __setfield_number(self, value): 
 169          if isinstance(value,USTRING): 
 170              self.__field_number=value 
 171          else: 
 172              self.__field_number=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 
 173   
 174 -    def __delfield_number(self): del self.__field_number 
 175   
 176      number=property(__getfield_number, __setfield_number, __delfield_number, None) 
 177   
 178 -    def __getfield_name(self): 
 179          return self.__field_name.getvalue() 
 180   
 181 -    def __setfield_name(self, value): 
 182          if isinstance(value,USTRING): 
 183              self.__field_name=value 
 184          else: 
 185              self.__field_name=USTRING(value,**{'sizeinbytes': 36, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
 186   
 187 -    def __delfield_name(self): del self.__field_name 
 188   
 189      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
 190   
 191 -    def __getfield_numberlength(self): 
 192          return self.__field_numberlength.getvalue() 
 193   
 194 -    def __setfield_numberlength(self, value): 
 195          if isinstance(value,UINT): 
 196              self.__field_numberlength=value 
 197          else: 
 198              self.__field_numberlength=UINT(value,**{'sizeinbytes': 1}) 
 199   
 200 -    def __delfield_numberlength(self): del self.__field_numberlength 
 201   
 202      numberlength=property(__getfield_numberlength, __setfield_numberlength, __delfield_numberlength, None) 
 203   
 204 -    def __getfield_status(self): 
 205          return self.__field_status.getvalue() 
 206   
 207 -    def __setfield_status(self, value): 
 208          if isinstance(value,UINT): 
 209              self.__field_status=value 
 210          else: 
 211              self.__field_status=UINT(value,**{'sizeinbytes': 1}) 
 212   
 213 -    def __delfield_status(self): del self.__field_status 
 214   
 215      status=property(__getfield_status, __setfield_status, __delfield_status, None) 
 216   
 217 -    def __getfield_pbnumbertype(self): 
 218          return self.__field_pbnumbertype.getvalue() 
 219   
 220 -    def __setfield_pbnumbertype(self, value): 
 221          if isinstance(value,UINT): 
 222              self.__field_pbnumbertype=value 
 223          else: 
 224              self.__field_pbnumbertype=UINT(value,**{'sizeinbytes': 1}) 
 225   
 226 -    def __delfield_pbnumbertype(self): del self.__field_pbnumbertype 
 227   
 228      pbnumbertype=property(__getfield_pbnumbertype, __setfield_pbnumbertype, __delfield_pbnumbertype, None) 
 229   
 230 -    def __getfield_unk1(self): 
 231          return self.__field_unk1.getvalue() 
 232   
 233 -    def __setfield_unk1(self, value): 
 234          if isinstance(value,UINT): 
 235              self.__field_unk1=value 
 236          else: 
 237              self.__field_unk1=UINT(value,**{'sizeinbytes': 4}) 
 238   
 239 -    def __delfield_unk1(self): del self.__field_unk1 
 240   
 241      unk1=property(__getfield_unk1, __setfield_unk1, __delfield_unk1, None) 
 242   
 243 -    def __getfield_pbentrynum(self): 
 244          return self.__field_pbentrynum.getvalue() 
 245   
 246 -    def __setfield_pbentrynum(self, value): 
 247          if isinstance(value,UINT): 
 248              self.__field_pbentrynum=value 
 249          else: 
 250              self.__field_pbentrynum=UINT(value,**{'sizeinbytes': 2}) 
 251   
 252 -    def __delfield_pbentrynum(self): del self.__field_pbentrynum 
 253   
 254      pbentrynum=property(__getfield_pbentrynum, __setfield_pbentrynum, __delfield_pbentrynum, None) 
 255   
 256 -    def __getfield_number_location(self): 
 257          return self.__field_number_location.getvalue() 
 258   
 259 -    def __setfield_number_location(self, value): 
 260          if isinstance(value,DATA): 
 261              self.__field_number_location=value 
 262          else: 
 263              self.__field_number_location=DATA(value,**{'sizeinbytes': 76}) 
 264   
 265 -    def __delfield_number_location(self): del self.__field_number_location 
 266   
 267      number_location=property(__getfield_number_location, __setfield_number_location, __delfield_number_location, None) 
 268   
 269 -    def iscontainer(self): 
 270          return True 
 271   
 272 -    def containerelements(self): 
 273          yield ('GPStime', self.__field_GPStime, None) 
 274          yield ('unk0', self.__field_unk0, None) 
 275          yield ('duration', self.__field_duration, None) 
 276          yield ('number', self.__field_number, None) 
 277          yield ('name', self.__field_name, None) 
 278          yield ('numberlength', self.__field_numberlength, None) 
 279          yield ('status', self.__field_status, None) 
 280          yield ('pbnumbertype', self.__field_pbnumbertype, None) 
 281          yield ('unk1', self.__field_unk1, None) 
 282          yield ('pbentrynum', self.__field_pbentrynum, None) 
 283          yield ('number_location', self.__field_number_location, None) 
 284   
 285   
 286   
 287   
 288 -class callhistory(BaseProtogenClass): 
 289      __fields=['numcalls', 'unk1', 'calls'] 
 290   
 291 -    def __init__(self, *args, **kwargs): 
 292          dict={} 
 293          # What was supplied to this function 
 294          dict.update(kwargs) 
 295          # Parent constructor 
 296          super(callhistory,self).__init__(**dict) 
 297          if self.__class__ is callhistory: 
 298              self._update(args,dict) 
 299   
 300   
 301 -    def getfields(self): 
 302          return self.__fields 
 303   
 304   
 305 -    def _update(self, args, kwargs): 
 306          super(callhistory,self)._update(args,kwargs) 
 307          keys=kwargs.keys() 
 308          for key in keys: 
 309              if key in self.__fields: 
 310                  setattr(self, key, kwargs[key]) 
 311                  del kwargs[key] 
 312          # Were any unrecognized kwargs passed in? 
 313          if __debug__: 
 314              self._complainaboutunusedargs(callhistory,kwargs) 
 315          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 316          # Make all P fields that haven't already been constructed 
 317   
 318   
 319 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 320          'Writes this packet to the supplied buffer' 
 321          self._bufferstartoffset=buf.getcurrentoffset() 
 322          self.__field_numcalls.writetobuffer(buf) 
 323          self.__field_unk1.writetobuffer(buf) 
 324          try: self.__field_calls 
 325          except: 
 326              self.__field_calls=LIST(**{'elementclass': call, 'length': self.numcalls}) 
 327          self.__field_calls.writetobuffer(buf) 
 328          self._bufferendoffset=buf.getcurrentoffset() 
 329          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 330   
 331   
 332 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 333          'Reads this packet from the supplied buffer' 
 334          self._bufferstartoffset=buf.getcurrentoffset() 
 335          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 336          self.__field_numcalls=UINT(**{'sizeinbytes': 4}) 
 337          self.__field_numcalls.readfrombuffer(buf) 
 338          self.__field_unk1=UINT(**{'sizeinbytes': 1}) 
 339          self.__field_unk1.readfrombuffer(buf) 
 340          self.__field_calls=LIST(**{'elementclass': call, 'length': self.numcalls}) 
 341          self.__field_calls.readfrombuffer(buf) 
 342          self._bufferendoffset=buf.getcurrentoffset() 
 343   
 344   
 345 -    def __getfield_numcalls(self): 
 346          return self.__field_numcalls.getvalue() 
 347   
 348 -    def __setfield_numcalls(self, value): 
 349          if isinstance(value,UINT): 
 350              self.__field_numcalls=value 
 351          else: 
 352              self.__field_numcalls=UINT(value,**{'sizeinbytes': 4}) 
 353   
 354 -    def __delfield_numcalls(self): del self.__field_numcalls 
 355   
 356      numcalls=property(__getfield_numcalls, __setfield_numcalls, __delfield_numcalls, None) 
 357   
 358 -    def __getfield_unk1(self): 
 359          return self.__field_unk1.getvalue() 
 360   
 361 -    def __setfield_unk1(self, value): 
 362          if isinstance(value,UINT): 
 363              self.__field_unk1=value 
 364          else: 
 365              self.__field_unk1=UINT(value,**{'sizeinbytes': 1}) 
 366   
 367 -    def __delfield_unk1(self): del self.__field_unk1 
 368   
 369      unk1=property(__getfield_unk1, __setfield_unk1, __delfield_unk1, None) 
 370   
 371 -    def __getfield_calls(self): 
 372          try: self.__field_calls 
 373          except: 
 374              self.__field_calls=LIST(**{'elementclass': call, 'length': self.numcalls}) 
 375          return self.__field_calls.getvalue() 
 376   
 377 -    def __setfield_calls(self, value): 
 378          if isinstance(value,LIST): 
 379              self.__field_calls=value 
 380          else: 
 381              self.__field_calls=LIST(value,**{'elementclass': call, 'length': self.numcalls}) 
 382   
 383 -    def __delfield_calls(self): del self.__field_calls 
 384   
 385      calls=property(__getfield_calls, __setfield_calls, __delfield_calls, None) 
 386   
 387 -    def iscontainer(self): 
 388          return True 
 389   
 390 -    def containerelements(self): 
 391          yield ('numcalls', self.__field_numcalls, None) 
 392          yield ('unk1', self.__field_unk1, None) 
 393          yield ('calls', self.__field_calls, None) 
 394   
 395   
 396   
 397   
 398 -class speeddial(BaseProtogenClass): 
 399      __fields=['entry', 'number'] 
 400   
 401 -    def __init__(self, *args, **kwargs): 
 402          dict={} 
 403          # What was supplied to this function 
 404          dict.update(kwargs) 
 405          # Parent constructor 
 406          super(speeddial,self).__init__(**dict) 
 407          if self.__class__ is speeddial: 
 408              self._update(args,dict) 
 409   
 410   
 411 -    def getfields(self): 
 412          return self.__fields 
 413   
 414   
 415 -    def _update(self, args, kwargs): 
 416          super(speeddial,self)._update(args,kwargs) 
 417          keys=kwargs.keys() 
 418          for key in keys: 
 419              if key in self.__fields: 
 420                  setattr(self, key, kwargs[key]) 
 421                  del kwargs[key] 
 422          # Were any unrecognized kwargs passed in? 
 423          if __debug__: 
 424              self._complainaboutunusedargs(speeddial,kwargs) 
 425          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 426          # Make all P fields that haven't already been constructed 
 427   
 428   
 429 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 430          'Writes this packet to the supplied buffer' 
 431          self._bufferstartoffset=buf.getcurrentoffset() 
 432          try: self.__field_entry 
 433          except: 
 434              self.__field_entry=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
 435          self.__field_entry.writetobuffer(buf) 
 436          try: self.__field_number 
 437          except: 
 438              self.__field_number=UINT(**{'sizeinbytes': 1, 'default': 0xff}) 
 439          self.__field_number.writetobuffer(buf) 
 440          self._bufferendoffset=buf.getcurrentoffset() 
 441          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 442   
 443   
 444 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 445          'Reads this packet from the supplied buffer' 
 446          self._bufferstartoffset=buf.getcurrentoffset() 
 447          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 448          self.__field_entry=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
 449          self.__field_entry.readfrombuffer(buf) 
 450          self.__field_number=UINT(**{'sizeinbytes': 1, 'default': 0xff}) 
 451          self.__field_number.readfrombuffer(buf) 
 452          self._bufferendoffset=buf.getcurrentoffset() 
 453   
 454   
 455 -    def __getfield_entry(self): 
 456          try: self.__field_entry 
 457          except: 
 458              self.__field_entry=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
 459          return self.__field_entry.getvalue() 
 460   
 461 -    def __setfield_entry(self, value): 
 462          if isinstance(value,UINT): 
 463              self.__field_entry=value 
 464          else: 
 465              self.__field_entry=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff}) 
 466   
 467 -    def __delfield_entry(self): del self.__field_entry 
 468   
 469      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, "0-based entry number") 
 470   
 471 -    def __getfield_number(self): 
 472          try: self.__field_number 
 473          except: 
 474              self.__field_number=UINT(**{'sizeinbytes': 1, 'default': 0xff}) 
 475          return self.__field_number.getvalue() 
 476   
 477 -    def __setfield_number(self, value): 
 478          if isinstance(value,UINT): 
 479              self.__field_number=value 
 480          else: 
 481              self.__field_number=UINT(value,**{'sizeinbytes': 1, 'default': 0xff}) 
 482   
 483 -    def __delfield_number(self): del self.__field_number 
 484   
 485      number=property(__getfield_number, __setfield_number, __delfield_number, "number type") 
 486   
 487 -    def iscontainer(self): 
 488          return True 
 489   
 490 -    def containerelements(self): 
 491          yield ('entry', self.__field_entry, "0-based entry number") 
 492          yield ('number', self.__field_number, "number type") 
 493   
 494 -    def valid(self): 
 495          return self.entry!=0xffff 
 496   
 497   
 498   
 499   
 500 -class speeddials(BaseProtogenClass): 
 501      __fields=['speeddials'] 
 502   
 503 -    def __init__(self, *args, **kwargs): 
 504          dict={} 
 505          # What was supplied to this function 
 506          dict.update(kwargs) 
 507          # Parent constructor 
 508          super(speeddials,self).__init__(**dict) 
 509          if self.__class__ is speeddials: 
 510              self._update(args,dict) 
 511   
 512   
 513 -    def getfields(self): 
 514          return self.__fields 
 515   
 516   
 517 -    def _update(self, args, kwargs): 
 518          super(speeddials,self)._update(args,kwargs) 
 519          keys=kwargs.keys() 
 520          for key in keys: 
 521              if key in self.__fields: 
 522                  setattr(self, key, kwargs[key]) 
 523                  del kwargs[key] 
 524          # Were any unrecognized kwargs passed in? 
 525          if __debug__: 
 526              self._complainaboutunusedargs(speeddials,kwargs) 
 527          if len(args): 
 528              dict2={'length': NUMSPEEDDIALS, 'elementclass': speeddial} 
 529              dict2.update(kwargs) 
 530              kwargs=dict2 
 531              self.__field_speeddials=LIST(*args,**dict2) 
 532          # Make all P fields that haven't already been constructed 
 533   
 534   
 535 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 536          'Writes this packet to the supplied buffer' 
 537          self._bufferstartoffset=buf.getcurrentoffset() 
 538          try: self.__field_speeddials 
 539          except: 
 540              self.__field_speeddials=LIST(**{'length': NUMSPEEDDIALS, 'elementclass': speeddial}) 
 541          self.__field_speeddials.writetobuffer(buf) 
 542          self._bufferendoffset=buf.getcurrentoffset() 
 543          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 544   
 545   
 546 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 547          'Reads this packet from the supplied buffer' 
 548          self._bufferstartoffset=buf.getcurrentoffset() 
 549          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 550          self.__field_speeddials=LIST(**{'length': NUMSPEEDDIALS, 'elementclass': speeddial}) 
 551          self.__field_speeddials.readfrombuffer(buf) 
 552          self._bufferendoffset=buf.getcurrentoffset() 
 553   
 554   
 555 -    def __getfield_speeddials(self): 
 556          try: self.__field_speeddials 
 557          except: 
 558              self.__field_speeddials=LIST(**{'length': NUMSPEEDDIALS, 'elementclass': speeddial}) 
 559          return self.__field_speeddials.getvalue() 
 560   
 561 -    def __setfield_speeddials(self, value): 
 562          if isinstance(value,LIST): 
 563              self.__field_speeddials=value 
 564          else: 
 565              self.__field_speeddials=LIST(value,**{'length': NUMSPEEDDIALS, 'elementclass': speeddial}) 
 566   
 567 -    def __delfield_speeddials(self): del self.__field_speeddials 
 568   
 569      speeddials=property(__getfield_speeddials, __setfield_speeddials, __delfield_speeddials, None) 
 570   
 571 -    def iscontainer(self): 
 572          return True 
 573   
 574 -    def containerelements(self): 
 575          yield ('speeddials', self.__field_speeddials, None) 
 576   
 577   
 578   
 579   
 580 -class pbfileentry(BaseProtogenClass): 
 581      __fields=['entry_tag', 'unk4', 'mod_date', 'unk0', 'entry_number1', 'entry_number0', 'name', 'group', 'unk1', 'emails', 'ringtone', 'wallpaper', 'numbertypes', 'unk2', 'numberindices', 'addressindex', 'unk3', 'memo', 'exit_tag', 'dontcare'] 
 582   
 583 -    def __init__(self, *args, **kwargs): 
 584          dict={} 
 585          # What was supplied to this function 
 586          dict.update(kwargs) 
 587          # Parent constructor 
 588          super(pbfileentry,self).__init__(**dict) 
 589          if self.__class__ is pbfileentry: 
 590              self._update(args,dict) 
 591   
 592   
 593 -    def getfields(self): 
 594          return self.__fields 
 595   
 596   
 597 -    def _update(self, args, kwargs): 
 598          super(pbfileentry,self)._update(args,kwargs) 
 599          keys=kwargs.keys() 
 600          for key in keys: 
 601              if key in self.__fields: 
 602                  setattr(self, key, kwargs[key]) 
 603                  del kwargs[key] 
 604          # Were any unrecognized kwargs passed in? 
 605          if __debug__: 
 606              self._complainaboutunusedargs(pbfileentry,kwargs) 
 607          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 608          # Make all P fields that haven't already been constructed 
 609   
 610   
 611 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 612          'Writes this packet to the supplied buffer' 
 613          self._bufferstartoffset=buf.getcurrentoffset() 
 614          try: self.__field_entry_tag 
 615          except: 
 616              self.__field_entry_tag=STRING(**{'sizeinbytes': 5,  'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '\xff\xff\xff\xff\xff' }) 
 617          self.__field_entry_tag.writetobuffer(buf) 
 618          if self.entry_tag==PB_ENTRY_SOR: 
 619              try: self.__field_unk4 
 620              except: 
 621                  self.__field_unk4=UINT(**{'sizeinbytes': 1,  'default': 0xff }) 
 622              self.__field_unk4.writetobuffer(buf) 
 623              try: self.__field_mod_date 
 624              except: 
 625                  self.__field_mod_date=PBDateTime(**{ 'defaulttocurrenttime': True }) 
 626              self.__field_mod_date.writetobuffer(buf) 
 627              try: self.__field_unk0 
 628              except: 
 629                  self.__field_unk0=STRING(**{'sizeinbytes': 6,  'terminator': None, 'default': '\xff\xff\xff\xff\xff\xff' }) 
 630              self.__field_unk0.writetobuffer(buf) 
 631              self.__field_entry_number1.writetobuffer(buf) 
 632              self.__field_entry_number0.writetobuffer(buf) 
 633              try: self.__field_name 
 634              except: 
 635                  self.__field_name=USTRING(**{'sizeinbytes': 34,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False }) 
 636              self.__field_name.writetobuffer(buf) 
 637              try: self.__field_group 
 638              except: 
 639                  self.__field_group=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
 640              self.__field_group.writetobuffer(buf) 
 641              try: self.__field_unk1 
 642              except: 
 643                  self.__field_unk1=UNKNOWN(**{'sizeinbytes': 58}) 
 644              self.__field_unk1.writetobuffer(buf) 
 645              try: self.__field_emails 
 646              except: 
 647                  self.__field_emails=LIST(**{'elementclass': _gen_p_lgvx11000_105, 'length': NUMEMAILS}) 
 648              self.__field_emails.writetobuffer(buf) 
 649              try: self.__field_ringtone 
 650              except: 
 651                  self.__field_ringtone=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
 652              self.__field_ringtone.writetobuffer(buf) 
 653              try: self.__field_wallpaper 
 654              except: 
 655                  self.__field_wallpaper=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
 656              self.__field_wallpaper.writetobuffer(buf) 
 657              try: self.__field_numbertypes 
 658              except: 
 659                  self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lgvx11000_109, 'length': NUMPHONENUMBERS}) 
 660              self.__field_numbertypes.writetobuffer(buf) 
 661              try: self.__field_unk2 
 662              except: 
 663                  self.__field_unk2=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
 664              self.__field_unk2.writetobuffer(buf) 
 665              try: self.__field_numberindices 
 666              except: 
 667                  self.__field_numberindices=LIST(**{'elementclass': _gen_p_lgvx11000_112, 'length': NUMPHONENUMBERS}) 
 668              self.__field_numberindices.writetobuffer(buf) 
 669              try: self.__field_addressindex 
 670              except: 
 671                  self.__field_addressindex=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
 672              self.__field_addressindex.writetobuffer(buf) 
 673              try: self.__field_unk3 
 674              except: 
 675                  self.__field_unk3=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
 676              self.__field_unk3.writetobuffer(buf) 
 677              try: self.__field_memo 
 678              except: 
 679                  self.__field_memo=USTRING(**{'sizeinbytes': 260,  'raiseonunterminatedread': False, 'default': '', 'encoding': PHONE_ENCODING }) 
 680              self.__field_memo.writetobuffer(buf) 
 681              try: self.__field_exit_tag 
 682              except: 
 683                  self.__field_exit_tag=USTRING(**{'sizeinbytes': 6,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '</PE>'}) 
 684              self.__field_exit_tag.writetobuffer(buf) 
 685          else: 
 686              try: self.__field_dontcare 
 687              except: 
 688                  self.__field_dontcare=DATA(**{'sizeinbytes': 507,  'default': '\xff'*507 }) 
 689              self.__field_dontcare.writetobuffer(buf) 
 690          self._bufferendoffset=buf.getcurrentoffset() 
 691          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 692   
 693   
 694 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 695          'Reads this packet from the supplied buffer' 
 696          self._bufferstartoffset=buf.getcurrentoffset() 
 697          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 698          self.__field_entry_tag=STRING(**{'sizeinbytes': 5,  'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '\xff\xff\xff\xff\xff' }) 
 699          self.__field_entry_tag.readfrombuffer(buf) 
 700          if self.entry_tag==PB_ENTRY_SOR: 
 701              self.__field_unk4=UINT(**{'sizeinbytes': 1,  'default': 0xff }) 
 702              self.__field_unk4.readfrombuffer(buf) 
 703              self.__field_mod_date=PBDateTime(**{ 'defaulttocurrenttime': True }) 
 704              self.__field_mod_date.readfrombuffer(buf) 
 705              self.__field_unk0=STRING(**{'sizeinbytes': 6,  'terminator': None, 'default': '\xff\xff\xff\xff\xff\xff' }) 
 706              self.__field_unk0.readfrombuffer(buf) 
 707              self.__field_entry_number1=UINT(**{'sizeinbytes': 4}) 
 708              self.__field_entry_number1.readfrombuffer(buf) 
 709              self.__field_entry_number0=UINT(**{'sizeinbytes': 2}) 
 710              self.__field_entry_number0.readfrombuffer(buf) 
 711              self.__field_name=USTRING(**{'sizeinbytes': 34,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False }) 
 712              self.__field_name.readfrombuffer(buf) 
 713              self.__field_group=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
 714              self.__field_group.readfrombuffer(buf) 
 715              self.__field_unk1=UNKNOWN(**{'sizeinbytes': 58}) 
 716              self.__field_unk1.readfrombuffer(buf) 
 717              self.__field_emails=LIST(**{'elementclass': _gen_p_lgvx11000_105, 'length': NUMEMAILS}) 
 718              self.__field_emails.readfrombuffer(buf) 
 719              self.__field_ringtone=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
 720              self.__field_ringtone.readfrombuffer(buf) 
 721              self.__field_wallpaper=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
 722              self.__field_wallpaper.readfrombuffer(buf) 
 723              self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lgvx11000_109, 'length': NUMPHONENUMBERS}) 
 724              self.__field_numbertypes.readfrombuffer(buf) 
 725              self.__field_unk2=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
 726              self.__field_unk2.readfrombuffer(buf) 
 727              self.__field_numberindices=LIST(**{'elementclass': _gen_p_lgvx11000_112, 'length': NUMPHONENUMBERS}) 
 728              self.__field_numberindices.readfrombuffer(buf) 
 729              self.__field_addressindex=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
 730              self.__field_addressindex.readfrombuffer(buf) 
 731              self.__field_unk3=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
 732              self.__field_unk3.readfrombuffer(buf) 
 733              self.__field_memo=USTRING(**{'sizeinbytes': 260,  'raiseonunterminatedread': False, 'default': '', 'encoding': PHONE_ENCODING }) 
 734              self.__field_memo.readfrombuffer(buf) 
 735              self.__field_exit_tag=USTRING(**{'sizeinbytes': 6,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '</PE>'}) 
 736              self.__field_exit_tag.readfrombuffer(buf) 
 737          else: 
 738              self.__field_dontcare=DATA(**{'sizeinbytes': 507,  'default': '\xff'*507 }) 
 739              self.__field_dontcare.readfrombuffer(buf) 
 740          self._bufferendoffset=buf.getcurrentoffset() 
 741   
 742   
 743 -    def __getfield_entry_tag(self): 
 744          try: self.__field_entry_tag 
 745          except: 
 746              self.__field_entry_tag=STRING(**{'sizeinbytes': 5,  'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '\xff\xff\xff\xff\xff' }) 
 747          return self.__field_entry_tag.getvalue() 
 748   
 749 -    def __setfield_entry_tag(self, value): 
 750          if isinstance(value,STRING): 
 751              self.__field_entry_tag=value 
 752          else: 
 753              self.__field_entry_tag=STRING(value,**{'sizeinbytes': 5,  'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '\xff\xff\xff\xff\xff' }) 
 754   
 755 -    def __delfield_entry_tag(self): del self.__field_entry_tag 
 756   
 757      entry_tag=property(__getfield_entry_tag, __setfield_entry_tag, __delfield_entry_tag, None) 
 758   
 759 -    def __getfield_unk4(self): 
 760          try: self.__field_unk4 
 761          except: 
 762              self.__field_unk4=UINT(**{'sizeinbytes': 1,  'default': 0xff }) 
 763          return self.__field_unk4.getvalue() 
 764   
 765 -    def __setfield_unk4(self, value): 
 766          if isinstance(value,UINT): 
 767              self.__field_unk4=value 
 768          else: 
 769              self.__field_unk4=UINT(value,**{'sizeinbytes': 1,  'default': 0xff }) 
 770   
 771 -    def __delfield_unk4(self): del self.__field_unk4 
 772   
 773      unk4=property(__getfield_unk4, __setfield_unk4, __delfield_unk4, None) 
 774   
 775 -    def __getfield_mod_date(self): 
 776          try: self.__field_mod_date 
 777          except: 
 778              self.__field_mod_date=PBDateTime(**{ 'defaulttocurrenttime': True }) 
 779          return self.__field_mod_date.getvalue() 
 780   
 781 -    def __setfield_mod_date(self, value): 
 782          if isinstance(value,PBDateTime): 
 783              self.__field_mod_date=value 
 784          else: 
 785              self.__field_mod_date=PBDateTime(value,**{ 'defaulttocurrenttime': True }) 
 786   
 787 -    def __delfield_mod_date(self): del self.__field_mod_date 
 788   
 789      mod_date=property(__getfield_mod_date, __setfield_mod_date, __delfield_mod_date, None) 
 790   
 791 -    def __getfield_unk0(self): 
 792          try: self.__field_unk0 
 793          except: 
 794              self.__field_unk0=STRING(**{'sizeinbytes': 6,  'terminator': None, 'default': '\xff\xff\xff\xff\xff\xff' }) 
 795          return self.__field_unk0.getvalue() 
 796   
 797 -    def __setfield_unk0(self, value): 
 798          if isinstance(value,STRING): 
 799              self.__field_unk0=value 
 800          else: 
 801              self.__field_unk0=STRING(value,**{'sizeinbytes': 6,  'terminator': None, 'default': '\xff\xff\xff\xff\xff\xff' }) 
 802   
 803 -    def __delfield_unk0(self): del self.__field_unk0 
 804   
 805      unk0=property(__getfield_unk0, __setfield_unk0, __delfield_unk0, None) 
 806   
 807 -    def __getfield_entry_number1(self): 
 808          return self.__field_entry_number1.getvalue() 
 809   
 810 -    def __setfield_entry_number1(self, value): 
 811          if isinstance(value,UINT): 
 812              self.__field_entry_number1=value 
 813          else: 
 814              self.__field_entry_number1=UINT(value,**{'sizeinbytes': 4}) 
 815   
 816 -    def __delfield_entry_number1(self): del self.__field_entry_number1 
 817   
 818      entry_number1=property(__getfield_entry_number1, __setfield_entry_number1, __delfield_entry_number1, None) 
 819   
 820 -    def __getfield_entry_number0(self): 
 821          return self.__field_entry_number0.getvalue() 
 822   
 823 -    def __setfield_entry_number0(self, value): 
 824          if isinstance(value,UINT): 
 825              self.__field_entry_number0=value 
 826          else: 
 827              self.__field_entry_number0=UINT(value,**{'sizeinbytes': 2}) 
 828   
 829 -    def __delfield_entry_number0(self): del self.__field_entry_number0 
 830   
 831      entry_number0=property(__getfield_entry_number0, __setfield_entry_number0, __delfield_entry_number0, None) 
 832   
 833 -    def __getfield_name(self): 
 834          try: self.__field_name 
 835          except: 
 836              self.__field_name=USTRING(**{'sizeinbytes': 34,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False }) 
 837          return self.__field_name.getvalue() 
 838   
 839 -    def __setfield_name(self, value): 
 840          if isinstance(value,USTRING): 
 841              self.__field_name=value 
 842          else: 
 843              self.__field_name=USTRING(value,**{'sizeinbytes': 34,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False }) 
 844   
 845 -    def __delfield_name(self): del self.__field_name 
 846   
 847      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
 848   
 849 -    def __getfield_group(self): 
 850          try: self.__field_group 
 851          except: 
 852              self.__field_group=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
 853          return self.__field_group.getvalue() 
 854   
 855 -    def __setfield_group(self, value): 
 856          if isinstance(value,UINT): 
 857              self.__field_group=value 
 858          else: 
 859              self.__field_group=UINT(value,**{'sizeinbytes': 2,  'default': 0 }) 
 860   
 861 -    def __delfield_group(self): del self.__field_group 
 862   
 863      group=property(__getfield_group, __setfield_group, __delfield_group, None) 
 864   
 865 -    def __getfield_unk1(self): 
 866          try: self.__field_unk1 
 867          except: 
 868              self.__field_unk1=UNKNOWN(**{'sizeinbytes': 58}) 
 869          return self.__field_unk1.getvalue() 
 870   
 871 -    def __setfield_unk1(self, value): 
 872          if isinstance(value,UNKNOWN): 
 873              self.__field_unk1=value 
 874          else: 
 875              self.__field_unk1=UNKNOWN(value,**{'sizeinbytes': 58}) 
 876   
 877 -    def __delfield_unk1(self): del self.__field_unk1 
 878   
 879      unk1=property(__getfield_unk1, __setfield_unk1, __delfield_unk1, None) 
 880   
 881 -    def __getfield_emails(self): 
 882          try: self.__field_emails 
 883          except: 
 884              self.__field_emails=LIST(**{'elementclass': _gen_p_lgvx11000_105, 'length': NUMEMAILS}) 
 885          return self.__field_emails.getvalue() 
 886   
 887 -    def __setfield_emails(self, value): 
 888          if isinstance(value,LIST): 
 889              self.__field_emails=value 
 890          else: 
 891              self.__field_emails=LIST(value,**{'elementclass': _gen_p_lgvx11000_105, 'length': NUMEMAILS}) 
 892   
 893 -    def __delfield_emails(self): del self.__field_emails 
 894   
 895      emails=property(__getfield_emails, __setfield_emails, __delfield_emails, None) 
 896   
 897 -    def __getfield_ringtone(self): 
 898          try: self.__field_ringtone 
 899          except: 
 900              self.__field_ringtone=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
 901          return self.__field_ringtone.getvalue() 
 902   
 903 -    def __setfield_ringtone(self, value): 
 904          if isinstance(value,UINT): 
 905              self.__field_ringtone=value 
 906          else: 
 907              self.__field_ringtone=UINT(value,**{'sizeinbytes': 2,  'default': 0xffff }) 
 908   
 909 -    def __delfield_ringtone(self): del self.__field_ringtone 
 910   
 911      ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 
 912   
 913 -    def __getfield_wallpaper(self): 
 914          try: self.__field_wallpaper 
 915          except: 
 916              self.__field_wallpaper=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
 917          return self.__field_wallpaper.getvalue() 
 918   
 919 -    def __setfield_wallpaper(self, value): 
 920          if isinstance(value,UINT): 
 921              self.__field_wallpaper=value 
 922          else: 
 923              self.__field_wallpaper=UINT(value,**{'sizeinbytes': 2,  'default': 0 }) 
 924   
 925 -    def __delfield_wallpaper(self): del self.__field_wallpaper 
 926   
 927      wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None) 
 928   
 929 -    def __getfield_numbertypes(self): 
 930          try: self.__field_numbertypes 
 931          except: 
 932              self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lgvx11000_109, 'length': NUMPHONENUMBERS}) 
 933          return self.__field_numbertypes.getvalue() 
 934   
 935 -    def __setfield_numbertypes(self, value): 
 936          if isinstance(value,LIST): 
 937              self.__field_numbertypes=value 
 938          else: 
 939              self.__field_numbertypes=LIST(value,**{'elementclass': _gen_p_lgvx11000_109, 'length': NUMPHONENUMBERS}) 
 940   
 941 -    def __delfield_numbertypes(self): del self.__field_numbertypes 
 942   
 943      numbertypes=property(__getfield_numbertypes, __setfield_numbertypes, __delfield_numbertypes, None) 
 944   
 945 -    def __getfield_unk2(self): 
 946          try: self.__field_unk2 
 947          except: 
 948              self.__field_unk2=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
 949          return self.__field_unk2.getvalue() 
 950   
 951 -    def __setfield_unk2(self, value): 
 952          if isinstance(value,UINT): 
 953              self.__field_unk2=value 
 954          else: 
 955              self.__field_unk2=UINT(value,**{'sizeinbytes': 1,  'default': 0 }) 
 956   
 957 -    def __delfield_unk2(self): del self.__field_unk2 
 958   
 959      unk2=property(__getfield_unk2, __setfield_unk2, __delfield_unk2, None) 
 960   
 961 -    def __getfield_numberindices(self): 
 962          try: self.__field_numberindices 
 963          except: 
 964              self.__field_numberindices=LIST(**{'elementclass': _gen_p_lgvx11000_112, 'length': NUMPHONENUMBERS}) 
 965          return self.__field_numberindices.getvalue() 
 966   
 967 -    def __setfield_numberindices(self, value): 
 968          if isinstance(value,LIST): 
 969              self.__field_numberindices=value 
 970          else: 
 971              self.__field_numberindices=LIST(value,**{'elementclass': _gen_p_lgvx11000_112, 'length': NUMPHONENUMBERS}) 
 972   
 973 -    def __delfield_numberindices(self): del self.__field_numberindices 
 974   
 975      numberindices=property(__getfield_numberindices, __setfield_numberindices, __delfield_numberindices, None) 
 976   
 977 -    def __getfield_addressindex(self): 
 978          try: self.__field_addressindex 
 979          except: 
 980              self.__field_addressindex=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
 981          return self.__field_addressindex.getvalue() 
 982   
 983 -    def __setfield_addressindex(self, value): 
 984          if isinstance(value,UINT): 
 985              self.__field_addressindex=value 
 986          else: 
 987              self.__field_addressindex=UINT(value,**{'sizeinbytes': 2,  'default': 0xffff }) 
 988   
 989 -    def __delfield_addressindex(self): del self.__field_addressindex 
 990   
 991      addressindex=property(__getfield_addressindex, __setfield_addressindex, __delfield_addressindex, None) 
 992   
 993 -    def __getfield_unk3(self): 
 994          try: self.__field_unk3 
 995          except: 
 996              self.__field_unk3=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
 997          return self.__field_unk3.getvalue() 
 998   
 999 -    def __setfield_unk3(self, value): 
1000          if isinstance(value,UINT): 
1001              self.__field_unk3=value 
1002          else: 
1003              self.__field_unk3=UINT(value,**{'sizeinbytes': 2,  'default': 0xffff }) 
1004   
1005 -    def __delfield_unk3(self): del self.__field_unk3 
1006   
1007      unk3=property(__getfield_unk3, __setfield_unk3, __delfield_unk3, None) 
1008   
1009 -    def __getfield_memo(self): 
1010          try: self.__field_memo 
1011          except: 
1012              self.__field_memo=USTRING(**{'sizeinbytes': 260,  'raiseonunterminatedread': False, 'default': '', 'encoding': PHONE_ENCODING }) 
1013          return self.__field_memo.getvalue() 
1014   
1015 -    def __setfield_memo(self, value): 
1016          if isinstance(value,USTRING): 
1017              self.__field_memo=value 
1018          else: 
1019              self.__field_memo=USTRING(value,**{'sizeinbytes': 260,  'raiseonunterminatedread': False, 'default': '', 'encoding': PHONE_ENCODING }) 
1020   
1021 -    def __delfield_memo(self): del self.__field_memo 
1022   
1023      memo=property(__getfield_memo, __setfield_memo, __delfield_memo, None) 
1024   
1025 -    def __getfield_exit_tag(self): 
1026          try: self.__field_exit_tag 
1027          except: 
1028              self.__field_exit_tag=USTRING(**{'sizeinbytes': 6,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '</PE>'}) 
1029          return self.__field_exit_tag.getvalue() 
1030   
1031 -    def __setfield_exit_tag(self, value): 
1032          if isinstance(value,USTRING): 
1033              self.__field_exit_tag=value 
1034          else: 
1035              self.__field_exit_tag=USTRING(value,**{'sizeinbytes': 6,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '</PE>'}) 
1036   
1037 -    def __delfield_exit_tag(self): del self.__field_exit_tag 
1038   
1039      exit_tag=property(__getfield_exit_tag, __setfield_exit_tag, __delfield_exit_tag, None) 
1040   
1041 -    def __getfield_dontcare(self): 
1042          try: self.__field_dontcare 
1043          except: 
1044              self.__field_dontcare=DATA(**{'sizeinbytes': 507,  'default': '\xff'*507 }) 
1045          return self.__field_dontcare.getvalue() 
1046   
1047 -    def __setfield_dontcare(self, value): 
1048          if isinstance(value,DATA): 
1049              self.__field_dontcare=value 
1050          else: 
1051              self.__field_dontcare=DATA(value,**{'sizeinbytes': 507,  'default': '\xff'*507 }) 
1052   
1053 -    def __delfield_dontcare(self): del self.__field_dontcare 
1054   
1055      dontcare=property(__getfield_dontcare, __setfield_dontcare, __delfield_dontcare, None) 
1056   
1057 -    def iscontainer(self): 
1058          return True 
1059   
1060 -    def containerelements(self): 
1061          yield ('entry_tag', self.__field_entry_tag, None) 
1062          if self.entry_tag==PB_ENTRY_SOR: 
1063              yield ('unk4', self.__field_unk4, None) 
1064              yield ('mod_date', self.__field_mod_date, None) 
1065              yield ('unk0', self.__field_unk0, None) 
1066              yield ('entry_number1', self.__field_entry_number1, None) 
1067              yield ('entry_number0', self.__field_entry_number0, None) 
1068              yield ('name', self.__field_name, None) 
1069              yield ('group', self.__field_group, None) 
1070              yield ('unk1', self.__field_unk1, None) 
1071              yield ('emails', self.__field_emails, None) 
1072              yield ('ringtone', self.__field_ringtone, None) 
1073              yield ('wallpaper', self.__field_wallpaper, None) 
1074              yield ('numbertypes', self.__field_numbertypes, None) 
1075              yield ('unk2', self.__field_unk2, None) 
1076              yield ('numberindices', self.__field_numberindices, None) 
1077              yield ('addressindex', self.__field_addressindex, None) 
1078              yield ('unk3', self.__field_unk3, None) 
1079              yield ('memo', self.__field_memo, None) 
1080              yield ('exit_tag', self.__field_exit_tag, None) 
1081          else: 
1082              yield ('dontcare', self.__field_dontcare, None) 
1083   
1084 -    def valid(self): 
1085          global PB_ENTRY_SOR 
1086          return self.entry_tag==PB_ENTRY_SOR and ord(self.name[0]) != 0xff 
1087   
1088   
1089   
1090   
1091 -class _gen_p_lgvx11000_105(BaseProtogenClass): 
1092      'Anonymous inner class' 
1093      __fields=['email'] 
1094   
1095 -    def __init__(self, *args, **kwargs): 
1096          dict={} 
1097          # What was supplied to this function 
1098          dict.update(kwargs) 
1099          # Parent constructor 
1100          super(_gen_p_lgvx11000_105,self).__init__(**dict) 
1101          if self.__class__ is _gen_p_lgvx11000_105: 
1102              self._update(args,dict) 
1103   
1104   
1105 -    def getfields(self): 
1106          return self.__fields 
1107   
1108   
1109 -    def _update(self, args, kwargs): 
1110          super(_gen_p_lgvx11000_105,self)._update(args,kwargs) 
1111          keys=kwargs.keys() 
1112          for key in keys: 
1113              if key in self.__fields: 
1114                  setattr(self, key, kwargs[key]) 
1115                  del kwargs[key] 
1116          # Were any unrecognized kwargs passed in? 
1117          if __debug__: 
1118              self._complainaboutunusedargs(_gen_p_lgvx11000_105,kwargs) 
1119          if len(args): 
1120              dict2={'sizeinbytes': 49, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False} 
1121              dict2.update(kwargs) 
1122              kwargs=dict2 
1123              self.__field_email=USTRING(*args,**dict2) 
1124          # Make all P fields that haven't already been constructed 
1125   
1126   
1127 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1128          'Writes this packet to the supplied buffer' 
1129          self._bufferstartoffset=buf.getcurrentoffset() 
1130          self.__field_email.writetobuffer(buf) 
1131          self._bufferendoffset=buf.getcurrentoffset() 
1132          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1133   
1134   
1135 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1136          'Reads this packet from the supplied buffer' 
1137          self._bufferstartoffset=buf.getcurrentoffset() 
1138          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1139          self.__field_email=USTRING(**{'sizeinbytes': 49, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
1140          self.__field_email.readfrombuffer(buf) 
1141          self._bufferendoffset=buf.getcurrentoffset() 
1142   
1143   
1144 -    def __getfield_email(self): 
1145          return self.__field_email.getvalue() 
1146   
1147 -    def __setfield_email(self, value): 
1148          if isinstance(value,USTRING): 
1149              self.__field_email=value 
1150          else: 
1151              self.__field_email=USTRING(value,**{'sizeinbytes': 49, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
1152   
1153 -    def __delfield_email(self): del self.__field_email 
1154   
1155      email=property(__getfield_email, __setfield_email, __delfield_email, None) 
1156   
1157 -    def iscontainer(self): 
1158          return True 
1159   
1160 -    def containerelements(self): 
1161          yield ('email', self.__field_email, None) 
1162   
1163   
1164   
1165   
1166 -class _gen_p_lgvx11000_109(BaseProtogenClass): 
1167      'Anonymous inner class' 
1168      __fields=['numbertype'] 
1169   
1170 -    def __init__(self, *args, **kwargs): 
1171          dict={} 
1172          # What was supplied to this function 
1173          dict.update(kwargs) 
1174          # Parent constructor 
1175          super(_gen_p_lgvx11000_109,self).__init__(**dict) 
1176          if self.__class__ is _gen_p_lgvx11000_109: 
1177              self._update(args,dict) 
1178   
1179   
1180 -    def getfields(self): 
1181          return self.__fields 
1182   
1183   
1184 -    def _update(self, args, kwargs): 
1185          super(_gen_p_lgvx11000_109,self)._update(args,kwargs) 
1186          keys=kwargs.keys() 
1187          for key in keys: 
1188              if key in self.__fields: 
1189                  setattr(self, key, kwargs[key]) 
1190                  del kwargs[key] 
1191          # Were any unrecognized kwargs passed in? 
1192          if __debug__: 
1193              self._complainaboutunusedargs(_gen_p_lgvx11000_109,kwargs) 
1194          if len(args): 
1195              dict2={'sizeinbytes': 1,  'default': 0 } 
1196              dict2.update(kwargs) 
1197              kwargs=dict2 
1198              self.__field_numbertype=UINT(*args,**dict2) 
1199          # Make all P fields that haven't already been constructed 
1200   
1201   
1202 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1203          'Writes this packet to the supplied buffer' 
1204          self._bufferstartoffset=buf.getcurrentoffset() 
1205          self.__field_numbertype.writetobuffer(buf) 
1206          self._bufferendoffset=buf.getcurrentoffset() 
1207          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1208   
1209   
1210 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1211          'Reads this packet from the supplied buffer' 
1212          self._bufferstartoffset=buf.getcurrentoffset() 
1213          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1214          self.__field_numbertype=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
1215          self.__field_numbertype.readfrombuffer(buf) 
1216          self._bufferendoffset=buf.getcurrentoffset() 
1217   
1218   
1219 -    def __getfield_numbertype(self): 
1220          return self.__field_numbertype.getvalue() 
1221   
1222 -    def __setfield_numbertype(self, value): 
1223          if isinstance(value,UINT): 
1224              self.__field_numbertype=value 
1225          else: 
1226              self.__field_numbertype=UINT(value,**{'sizeinbytes': 1,  'default': 0 }) 
1227   
1228 -    def __delfield_numbertype(self): del self.__field_numbertype 
1229   
1230      numbertype=property(__getfield_numbertype, __setfield_numbertype, __delfield_numbertype, None) 
1231   
1232 -    def iscontainer(self): 
1233          return True 
1234   
1235 -    def containerelements(self): 
1236          yield ('numbertype', self.__field_numbertype, None) 
1237   
1238   
1239   
1240   
1241 -class _gen_p_lgvx11000_112(BaseProtogenClass): 
1242      'Anonymous inner class' 
1243      __fields=['numberindex'] 
1244   
1245 -    def __init__(self, *args, **kwargs): 
1246          dict={} 
1247          # What was supplied to this function 
1248          dict.update(kwargs) 
1249          # Parent constructor 
1250          super(_gen_p_lgvx11000_112,self).__init__(**dict) 
1251          if self.__class__ is _gen_p_lgvx11000_112: 
1252              self._update(args,dict) 
1253   
1254   
1255 -    def getfields(self): 
1256          return self.__fields 
1257   
1258   
1259 -    def _update(self, args, kwargs): 
1260          super(_gen_p_lgvx11000_112,self)._update(args,kwargs) 
1261          keys=kwargs.keys() 
1262          for key in keys: 
1263              if key in self.__fields: 
1264                  setattr(self, key, kwargs[key]) 
1265                  del kwargs[key] 
1266          # Were any unrecognized kwargs passed in? 
1267          if __debug__: 
1268              self._complainaboutunusedargs(_gen_p_lgvx11000_112,kwargs) 
1269          if len(args): 
1270              dict2={'sizeinbytes': 2,  'default': 0xffff } 
1271              dict2.update(kwargs) 
1272              kwargs=dict2 
1273              self.__field_numberindex=UINT(*args,**dict2) 
1274          # Make all P fields that haven't already been constructed 
1275   
1276   
1277 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1278          'Writes this packet to the supplied buffer' 
1279          self._bufferstartoffset=buf.getcurrentoffset() 
1280          self.__field_numberindex.writetobuffer(buf) 
1281          self._bufferendoffset=buf.getcurrentoffset() 
1282          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1283   
1284   
1285 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1286          'Reads this packet from the supplied buffer' 
1287          self._bufferstartoffset=buf.getcurrentoffset() 
1288          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1289          self.__field_numberindex=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
1290          self.__field_numberindex.readfrombuffer(buf) 
1291          self._bufferendoffset=buf.getcurrentoffset() 
1292   
1293   
1294 -    def __getfield_numberindex(self): 
1295          return self.__field_numberindex.getvalue() 
1296   
1297 -    def __setfield_numberindex(self, value): 
1298          if isinstance(value,UINT): 
1299              self.__field_numberindex=value 
1300          else: 
1301              self.__field_numberindex=UINT(value,**{'sizeinbytes': 2,  'default': 0xffff }) 
1302   
1303 -    def __delfield_numberindex(self): del self.__field_numberindex 
1304   
1305      numberindex=property(__getfield_numberindex, __setfield_numberindex, __delfield_numberindex, None) 
1306   
1307 -    def iscontainer(self): 
1308          return True 
1309   
1310 -    def containerelements(self): 
1311          yield ('numberindex', self.__field_numberindex, None) 
1312   
1313   
1314   
1315   
1316 -class pbfile(BaseProtogenClass): 
1317      __fields=['items', 'eof_tag', 'model_name', 'mod_date', 'blanks', 'eof_close_tag'] 
1318   
1319 -    def __init__(self, *args, **kwargs): 
1320          dict={} 
1321          # What was supplied to this function 
1322          dict.update(kwargs) 
1323          # Parent constructor 
1324          super(pbfile,self).__init__(**dict) 
1325          if self.__class__ is pbfile: 
1326              self._update(args,dict) 
1327   
1328   
1329 -    def getfields(self): 
1330          return self.__fields 
1331   
1332   
1333 -    def _update(self, args, kwargs): 
1334          super(pbfile,self)._update(args,kwargs) 
1335          keys=kwargs.keys() 
1336          for key in keys: 
1337              if key in self.__fields: 
1338                  setattr(self, key, kwargs[key]) 
1339                  del kwargs[key] 
1340          # Were any unrecognized kwargs passed in? 
1341          if __debug__: 
1342              self._complainaboutunusedargs(pbfile,kwargs) 
1343          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1344          # Make all P fields that haven't already been constructed 
1345   
1346   
1347 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1348          'Writes this packet to the supplied buffer' 
1349          self._bufferstartoffset=buf.getcurrentoffset() 
1350          try: self.__field_items 
1351          except: 
1352              self.__field_items=LIST(**{ 'elementclass': pbfileentry,             'length': NUMPHONEBOOKENTRIES,             'createdefault': True}) 
1353          self.__field_items.writetobuffer(buf) 
1354          try: self.__field_eof_tag 
1355          except: 
1356              self.__field_eof_tag=STRING(**{'sizeinbytes': 6,  'default': '<HPE>',               'raiseonunterminatedread': False,               'raiseontruncate': False }) 
1357          self.__field_eof_tag.writetobuffer(buf) 
1358          try: self.__field_model_name 
1359          except: 
1360              self.__field_model_name=STRING(**{'sizeinbytes': 10,  'raiseonunterminatedread': False,                'raiseontruncate': False }) 
1361          self.__field_model_name.writetobuffer(buf) 
1362          try: self.__field_mod_date 
1363          except: 
1364              self.__field_mod_date=PBDateTime(**{ 'defaulttocurrenttime': True }) 
1365          self.__field_mod_date.writetobuffer(buf) 
1366          try: self.__field_blanks 
1367          except: 
1368              self.__field_blanks=DATA(**{'sizeinbytes': 477,  'default': '\x00'*221 }) 
1369          self.__field_blanks.writetobuffer(buf) 
1370          try: self.__field_eof_close_tag 
1371          except: 
1372              self.__field_eof_close_tag=STRING(**{'sizeinbytes': 7,  'default': '</HPE>',               'raiseonunterminatedread': False,               'raiseontruncate': False  }) 
1373          self.__field_eof_close_tag.writetobuffer(buf) 
1374          self._bufferendoffset=buf.getcurrentoffset() 
1375          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1376   
1377   
1378 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1379          'Reads this packet from the supplied buffer' 
1380          self._bufferstartoffset=buf.getcurrentoffset() 
1381          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1382          self.__field_items=LIST(**{ 'elementclass': pbfileentry,             'length': NUMPHONEBOOKENTRIES,             'createdefault': True}) 
1383          self.__field_items.readfrombuffer(buf) 
1384          self.__field_eof_tag=STRING(**{'sizeinbytes': 6,  'default': '<HPE>',               'raiseonunterminatedread': False,               'raiseontruncate': False }) 
1385          self.__field_eof_tag.readfrombuffer(buf) 
1386          self.__field_model_name=STRING(**{'sizeinbytes': 10,  'raiseonunterminatedread': False,                'raiseontruncate': False }) 
1387          self.__field_model_name.readfrombuffer(buf) 
1388          self.__field_mod_date=PBDateTime(**{ 'defaulttocurrenttime': True }) 
1389          self.__field_mod_date.readfrombuffer(buf) 
1390          self.__field_blanks=DATA(**{'sizeinbytes': 477,  'default': '\x00'*221 }) 
1391          self.__field_blanks.readfrombuffer(buf) 
1392          self.__field_eof_close_tag=STRING(**{'sizeinbytes': 7,  'default': '</HPE>',               'raiseonunterminatedread': False,               'raiseontruncate': False  }) 
1393          self.__field_eof_close_tag.readfrombuffer(buf) 
1394          self._bufferendoffset=buf.getcurrentoffset() 
1395   
1396   
1397 -    def __getfield_items(self): 
1398          try: self.__field_items 
1399          except: 
1400              self.__field_items=LIST(**{ 'elementclass': pbfileentry,             'length': NUMPHONEBOOKENTRIES,             'createdefault': True}) 
1401          return self.__field_items.getvalue() 
1402   
1403 -    def __setfield_items(self, value): 
1404          if isinstance(value,LIST): 
1405              self.__field_items=value 
1406          else: 
1407              self.__field_items=LIST(value,**{ 'elementclass': pbfileentry,             'length': NUMPHONEBOOKENTRIES,             'createdefault': True}) 
1408   
1409 -    def __delfield_items(self): del self.__field_items 
1410   
1411      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
1412   
1413 -    def __getfield_eof_tag(self): 
1414          try: self.__field_eof_tag 
1415          except: 
1416              self.__field_eof_tag=STRING(**{'sizeinbytes': 6,  'default': '<HPE>',               'raiseonunterminatedread': False,               'raiseontruncate': False }) 
1417          return self.__field_eof_tag.getvalue() 
1418   
1419 -    def __setfield_eof_tag(self, value): 
1420          if isinstance(value,STRING): 
1421              self.__field_eof_tag=value 
1422          else: 
1423              self.__field_eof_tag=STRING(value,**{'sizeinbytes': 6,  'default': '<HPE>',               'raiseonunterminatedread': False,               'raiseontruncate': False }) 
1424   
1425 -    def __delfield_eof_tag(self): del self.__field_eof_tag 
1426   
1427      eof_tag=property(__getfield_eof_tag, __setfield_eof_tag, __delfield_eof_tag, None) 
1428   
1429 -    def __getfield_model_name(self): 
1430          try: self.__field_model_name 
1431          except: 
1432              self.__field_model_name=STRING(**{'sizeinbytes': 10,  'raiseonunterminatedread': False,                'raiseontruncate': False }) 
1433          return self.__field_model_name.getvalue() 
1434   
1435 -    def __setfield_model_name(self, value): 
1436          if isinstance(value,STRING): 
1437              self.__field_model_name=value 
1438          else: 
1439              self.__field_model_name=STRING(value,**{'sizeinbytes': 10,  'raiseonunterminatedread': False,                'raiseontruncate': False }) 
1440   
1441 -    def __delfield_model_name(self): del self.__field_model_name 
1442   
1443      model_name=property(__getfield_model_name, __setfield_model_name, __delfield_model_name, None) 
1444   
1445 -    def __getfield_mod_date(self): 
1446          try: self.__field_mod_date 
1447          except: 
1448              self.__field_mod_date=PBDateTime(**{ 'defaulttocurrenttime': True }) 
1449          return self.__field_mod_date.getvalue() 
1450   
1451 -    def __setfield_mod_date(self, value): 
1452          if isinstance(value,PBDateTime): 
1453              self.__field_mod_date=value 
1454          else: 
1455              self.__field_mod_date=PBDateTime(value,**{ 'defaulttocurrenttime': True }) 
1456   
1457 -    def __delfield_mod_date(self): del self.__field_mod_date 
1458   
1459      mod_date=property(__getfield_mod_date, __setfield_mod_date, __delfield_mod_date, None) 
1460   
1461 -    def __getfield_blanks(self): 
1462          try: self.__field_blanks 
1463          except: 
1464              self.__field_blanks=DATA(**{'sizeinbytes': 477,  'default': '\x00'*221 }) 
1465          return self.__field_blanks.getvalue() 
1466   
1467 -    def __setfield_blanks(self, value): 
1468          if isinstance(value,DATA): 
1469              self.__field_blanks=value 
1470          else: 
1471              self.__field_blanks=DATA(value,**{'sizeinbytes': 477,  'default': '\x00'*221 }) 
1472   
1473 -    def __delfield_blanks(self): del self.__field_blanks 
1474   
1475      blanks=property(__getfield_blanks, __setfield_blanks, __delfield_blanks, None) 
1476   
1477 -    def __getfield_eof_close_tag(self): 
1478          try: self.__field_eof_close_tag 
1479          except: 
1480              self.__field_eof_close_tag=STRING(**{'sizeinbytes': 7,  'default': '</HPE>',               'raiseonunterminatedread': False,               'raiseontruncate': False  }) 
1481          return self.__field_eof_close_tag.getvalue() 
1482   
1483 -    def __setfield_eof_close_tag(self, value): 
1484          if isinstance(value,STRING): 
1485              self.__field_eof_close_tag=value 
1486          else: 
1487              self.__field_eof_close_tag=STRING(value,**{'sizeinbytes': 7,  'default': '</HPE>',               'raiseonunterminatedread': False,               'raiseontruncate': False  }) 
1488   
1489 -    def __delfield_eof_close_tag(self): del self.__field_eof_close_tag 
1490   
1491      eof_close_tag=property(__getfield_eof_close_tag, __setfield_eof_close_tag, __delfield_eof_close_tag, None) 
1492   
1493 -    def iscontainer(self): 
1494          return True 
1495   
1496 -    def containerelements(self): 
1497          yield ('items', self.__field_items, None) 
1498          yield ('eof_tag', self.__field_eof_tag, None) 
1499          yield ('model_name', self.__field_model_name, None) 
1500          yield ('mod_date', self.__field_mod_date, None) 
1501          yield ('blanks', self.__field_blanks, None) 
1502          yield ('eof_close_tag', self.__field_eof_close_tag, None) 
1503   
1504   
1505   
1506   
1507 -class pafileentry(BaseProtogenClass): 
1508      __fields=['entry_tag', 'pad', 'mod_date', 'zeros', 'index', 'pb_entry', 'street', 'city', 'state', 'zip_code', 'country', 'exit_tag', 'dontcare'] 
1509   
1510 -    def __init__(self, *args, **kwargs): 
1511          dict={} 
1512          # What was supplied to this function 
1513          dict.update(kwargs) 
1514          # Parent constructor 
1515          super(pafileentry,self).__init__(**dict) 
1516          if self.__class__ is pafileentry: 
1517              self._update(args,dict) 
1518   
1519   
1520 -    def getfields(self): 
1521          return self.__fields 
1522   
1523   
1524 -    def _update(self, args, kwargs): 
1525          super(pafileentry,self)._update(args,kwargs) 
1526          keys=kwargs.keys() 
1527          for key in keys: 
1528              if key in self.__fields: 
1529                  setattr(self, key, kwargs[key]) 
1530                  del kwargs[key] 
1531          # Were any unrecognized kwargs passed in? 
1532          if __debug__: 
1533              self._complainaboutunusedargs(pafileentry,kwargs) 
1534          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1535          # Make all P fields that haven't already been constructed 
1536   
1537   
1538 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1539          'Writes this packet to the supplied buffer' 
1540          self._bufferstartoffset=buf.getcurrentoffset() 
1541          try: self.__field_entry_tag 
1542          except: 
1543              self.__field_entry_tag=STRING(**{'sizeinbytes': 5,  'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '\xff\xff\xff\xff\xff' }) 
1544          self.__field_entry_tag.writetobuffer(buf) 
1545          if self.entry_tag==PA_ENTRY_SOR: 
1546              try: self.__field_pad 
1547              except: 
1548                  self.__field_pad=UINT(**{'sizeinbytes': 1,  'default': 0x00 }) 
1549              self.__field_pad.writetobuffer(buf) 
1550              try: self.__field_mod_date 
1551              except: 
1552                  self.__field_mod_date=PBDateTime(**{ 'defaulttocurrenttime': True }) 
1553              self.__field_mod_date.writetobuffer(buf) 
1554              try: self.__field_zeros 
1555              except: 
1556                  self.__field_zeros=UNKNOWN(**{'sizeinbytes': 6}) 
1557              self.__field_zeros.writetobuffer(buf) 
1558              try: self.__field_index 
1559              except: 
1560                  self.__field_index=UINT(**{'sizeinbytes': 2}) 
1561              self.__field_index.writetobuffer(buf) 
1562              try: self.__field_pb_entry 
1563              except: 
1564                  self.__field_pb_entry=UINT(**{'sizeinbytes': 2}) 
1565              self.__field_pb_entry.writetobuffer(buf) 
1566              try: self.__field_street 
1567              except: 
1568                  self.__field_street=USTRING(**{'sizeinbytes': 52,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' }) 
1569              self.__field_street.writetobuffer(buf) 
1570              try: self.__field_city 
1571              except: 
1572                  self.__field_city=USTRING(**{'sizeinbytes': 52,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' }) 
1573              self.__field_city.writetobuffer(buf) 
1574              try: self.__field_state 
1575              except: 
1576                  self.__field_state=USTRING(**{'sizeinbytes': 52,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' }) 
1577              self.__field_state.writetobuffer(buf) 
1578              try: self.__field_zip_code 
1579              except: 
1580                  self.__field_zip_code=USTRING(**{'sizeinbytes': 13,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' }) 
1581              self.__field_zip_code.writetobuffer(buf) 
1582              try: self.__field_country 
1583              except: 
1584                  self.__field_country=USTRING(**{'sizeinbytes': 52,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' }) 
1585              self.__field_country.writetobuffer(buf) 
1586              try: self.__field_exit_tag 
1587              except: 
1588                  self.__field_exit_tag=USTRING(**{'sizeinbytes': 6,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '</PA>'}) 
1589              self.__field_exit_tag.writetobuffer(buf) 
1590          else: 
1591              try: self.__field_dontcare 
1592              except: 
1593                  self.__field_dontcare=DATA(**{'sizeinbytes': 250,  'default': '\xff'*250 }) 
1594              self.__field_dontcare.writetobuffer(buf) 
1595          self._bufferendoffset=buf.getcurrentoffset() 
1596          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1597   
1598   
1599 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1600          'Reads this packet from the supplied buffer' 
1601          self._bufferstartoffset=buf.getcurrentoffset() 
1602          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1603          self.__field_entry_tag=STRING(**{'sizeinbytes': 5,  'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '\xff\xff\xff\xff\xff' }) 
1604          self.__field_entry_tag.readfrombuffer(buf) 
1605          if self.entry_tag==PA_ENTRY_SOR: 
1606              self.__field_pad=UINT(**{'sizeinbytes': 1,  'default': 0x00 }) 
1607              self.__field_pad.readfrombuffer(buf) 
1608              self.__field_mod_date=PBDateTime(**{ 'defaulttocurrenttime': True }) 
1609              self.__field_mod_date.readfrombuffer(buf) 
1610              self.__field_zeros=UNKNOWN(**{'sizeinbytes': 6}) 
1611              self.__field_zeros.readfrombuffer(buf) 
1612              self.__field_index=UINT(**{'sizeinbytes': 2}) 
1613              self.__field_index.readfrombuffer(buf) 
1614              self.__field_pb_entry=UINT(**{'sizeinbytes': 2}) 
1615              self.__field_pb_entry.readfrombuffer(buf) 
1616              self.__field_street=USTRING(**{'sizeinbytes': 52,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' }) 
1617              self.__field_street.readfrombuffer(buf) 
1618              self.__field_city=USTRING(**{'sizeinbytes': 52,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' }) 
1619              self.__field_city.readfrombuffer(buf) 
1620              self.__field_state=USTRING(**{'sizeinbytes': 52,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' }) 
1621              self.__field_state.readfrombuffer(buf) 
1622              self.__field_zip_code=USTRING(**{'sizeinbytes': 13,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' }) 
1623              self.__field_zip_code.readfrombuffer(buf) 
1624              self.__field_country=USTRING(**{'sizeinbytes': 52,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' }) 
1625              self.__field_country.readfrombuffer(buf) 
1626              self.__field_exit_tag=USTRING(**{'sizeinbytes': 6,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '</PA>'}) 
1627              self.__field_exit_tag.readfrombuffer(buf) 
1628          else: 
1629              self.__field_dontcare=DATA(**{'sizeinbytes': 250,  'default': '\xff'*250 }) 
1630              self.__field_dontcare.readfrombuffer(buf) 
1631          self._bufferendoffset=buf.getcurrentoffset() 
1632   
1633   
1634 -    def __getfield_entry_tag(self): 
1635          try: self.__field_entry_tag 
1636          except: 
1637              self.__field_entry_tag=STRING(**{'sizeinbytes': 5,  'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '\xff\xff\xff\xff\xff' }) 
1638          return self.__field_entry_tag.getvalue() 
1639   
1640 -    def __setfield_entry_tag(self, value): 
1641          if isinstance(value,STRING): 
1642              self.__field_entry_tag=value 
1643          else: 
1644              self.__field_entry_tag=STRING(value,**{'sizeinbytes': 5,  'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '\xff\xff\xff\xff\xff' }) 
1645   
1646 -    def __delfield_entry_tag(self): del self.__field_entry_tag 
1647   
1648      entry_tag=property(__getfield_entry_tag, __setfield_entry_tag, __delfield_entry_tag, None) 
1649   
1650 -    def __getfield_pad(self): 
1651          try: self.__field_pad 
1652          except: 
1653              self.__field_pad=UINT(**{'sizeinbytes': 1,  'default': 0x00 }) 
1654          return self.__field_pad.getvalue() 
1655   
1656 -    def __setfield_pad(self, value): 
1657          if isinstance(value,UINT): 
1658              self.__field_pad=value 
1659          else: 
1660              self.__field_pad=UINT(value,**{'sizeinbytes': 1,  'default': 0x00 }) 
1661   
1662 -    def __delfield_pad(self): del self.__field_pad 
1663   
1664      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
1665   
1666 -    def __getfield_mod_date(self): 
1667          try: self.__field_mod_date 
1668          except: 
1669              self.__field_mod_date=PBDateTime(**{ 'defaulttocurrenttime': True }) 
1670          return self.__field_mod_date.getvalue() 
1671   
1672 -    def __setfield_mod_date(self, value): 
1673          if isinstance(value,PBDateTime): 
1674              self.__field_mod_date=value 
1675          else: 
1676              self.__field_mod_date=PBDateTime(value,**{ 'defaulttocurrenttime': True }) 
1677   
1678 -    def __delfield_mod_date(self): del self.__field_mod_date 
1679   
1680      mod_date=property(__getfield_mod_date, __setfield_mod_date, __delfield_mod_date, None) 
1681   
1682 -    def __getfield_zeros(self): 
1683          try: self.__field_zeros 
1684          except: 
1685              self.__field_zeros=UNKNOWN(**{'sizeinbytes': 6}) 
1686          return self.__field_zeros.getvalue() 
1687   
1688 -    def __setfield_zeros(self, value): 
1689          if isinstance(value,UNKNOWN): 
1690              self.__field_zeros=value 
1691          else: 
1692              self.__field_zeros=UNKNOWN(value,**{'sizeinbytes': 6}) 
1693   
1694 -    def __delfield_zeros(self): del self.__field_zeros 
1695   
1696      zeros=property(__getfield_zeros, __setfield_zeros, __delfield_zeros, None) 
1697   
1698 -    def __getfield_index(self): 
1699          try: self.__field_index 
1700          except: 
1701              self.__field_index=UINT(**{'sizeinbytes': 2}) 
1702          return self.__field_index.getvalue() 
1703   
1704 -    def __setfield_index(self, value): 
1705          if isinstance(value,UINT): 
1706              self.__field_index=value 
1707          else: 
1708              self.__field_index=UINT(value,**{'sizeinbytes': 2}) 
1709   
1710 -    def __delfield_index(self): del self.__field_index 
1711   
1712      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
1713   
1714 -    def __getfield_pb_entry(self): 
1715          try: self.__field_pb_entry 
1716          except: 
1717              self.__field_pb_entry=UINT(**{'sizeinbytes': 2}) 
1718          return self.__field_pb_entry.getvalue() 
1719   
1720 -    def __setfield_pb_entry(self, value): 
1721          if isinstance(value,UINT): 
1722              self.__field_pb_entry=value 
1723          else: 
1724              self.__field_pb_entry=UINT(value,**{'sizeinbytes': 2}) 
1725   
1726 -    def __delfield_pb_entry(self): del self.__field_pb_entry 
1727   
1728      pb_entry=property(__getfield_pb_entry, __setfield_pb_entry, __delfield_pb_entry, None) 
1729   
1730 -    def __getfield_street(self): 
1731          try: self.__field_street 
1732          except: 
1733              self.__field_street=USTRING(**{'sizeinbytes': 52,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' }) 
1734          return self.__field_street.getvalue() 
1735   
1736 -    def __setfield_street(self, value): 
1737          if isinstance(value,USTRING): 
1738              self.__field_street=value 
1739          else: 
1740              self.__field_street=USTRING(value,**{'sizeinbytes': 52,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' }) 
1741   
1742 -    def __delfield_street(self): del self.__field_street 
1743   
1744      street=property(__getfield_street, __setfield_street, __delfield_street, None) 
1745   
1746 -    def __getfield_city(self): 
1747          try: self.__field_city 
1748          except: 
1749              self.__field_city=USTRING(**{'sizeinbytes': 52,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' }) 
1750          return self.__field_city.getvalue() 
1751   
1752 -    def __setfield_city(self, value): 
1753          if isinstance(value,USTRING): 
1754              self.__field_city=value 
1755          else: 
1756              self.__field_city=USTRING(value,**{'sizeinbytes': 52,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' }) 
1757   
1758 -    def __delfield_city(self): del self.__field_city 
1759   
1760      city=property(__getfield_city, __setfield_city, __delfield_city, None) 
1761   
1762 -    def __getfield_state(self): 
1763          try: self.__field_state 
1764          except: 
1765              self.__field_state=USTRING(**{'sizeinbytes': 52,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' }) 
1766          return self.__field_state.getvalue() 
1767   
1768 -    def __setfield_state(self, value): 
1769          if isinstance(value,USTRING): 
1770              self.__field_state=value 
1771          else: 
1772              self.__field_state=USTRING(value,**{'sizeinbytes': 52,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' }) 
1773   
1774 -    def __delfield_state(self): del self.__field_state 
1775   
1776      state=property(__getfield_state, __setfield_state, __delfield_state, None) 
1777   
1778 -    def __getfield_zip_code(self): 
1779          try: self.__field_zip_code 
1780          except: 
1781              self.__field_zip_code=USTRING(**{'sizeinbytes': 13,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' }) 
1782          return self.__field_zip_code.getvalue() 
1783   
1784 -    def __setfield_zip_code(self, value): 
1785          if isinstance(value,USTRING): 
1786              self.__field_zip_code=value 
1787          else: 
1788              self.__field_zip_code=USTRING(value,**{'sizeinbytes': 13,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' }) 
1789   
1790 -    def __delfield_zip_code(self): del self.__field_zip_code 
1791   
1792      zip_code=property(__getfield_zip_code, __setfield_zip_code, __delfield_zip_code, None) 
1793   
1794 -    def __getfield_country(self): 
1795          try: self.__field_country 
1796          except: 
1797              self.__field_country=USTRING(**{'sizeinbytes': 52,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' }) 
1798          return self.__field_country.getvalue() 
1799   
1800 -    def __setfield_country(self, value): 
1801          if isinstance(value,USTRING): 
1802              self.__field_country=value 
1803          else: 
1804              self.__field_country=USTRING(value,**{'sizeinbytes': 52,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' }) 
1805   
1806 -    def __delfield_country(self): del self.__field_country 
1807   
1808      country=property(__getfield_country, __setfield_country, __delfield_country, None) 
1809   
1810 -    def __getfield_exit_tag(self): 
1811          try: self.__field_exit_tag 
1812          except: 
1813              self.__field_exit_tag=USTRING(**{'sizeinbytes': 6,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '</PA>'}) 
1814          return self.__field_exit_tag.getvalue() 
1815   
1816 -    def __setfield_exit_tag(self, value): 
1817          if isinstance(value,USTRING): 
1818              self.__field_exit_tag=value 
1819          else: 
1820              self.__field_exit_tag=USTRING(value,**{'sizeinbytes': 6,  'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '</PA>'}) 
1821   
1822 -    def __delfield_exit_tag(self): del self.__field_exit_tag 
1823   
1824      exit_tag=property(__getfield_exit_tag, __setfield_exit_tag, __delfield_exit_tag, None) 
1825   
1826 -    def __getfield_dontcare(self): 
1827          try: self.__field_dontcare 
1828          except: 
1829              self.__field_dontcare=DATA(**{'sizeinbytes': 250,  'default': '\xff'*250 }) 
1830          return self.__field_dontcare.getvalue() 
1831   
1832 -    def __setfield_dontcare(self, value): 
1833          if isinstance(value,DATA): 
1834              self.__field_dontcare=value 
1835          else: 
1836              self.__field_dontcare=DATA(value,**{'sizeinbytes': 250,  'default': '\xff'*250 }) 
1837   
1838 -    def __delfield_dontcare(self): del self.__field_dontcare 
1839   
1840      dontcare=property(__getfield_dontcare, __setfield_dontcare, __delfield_dontcare, None) 
1841   
1842 -    def iscontainer(self): 
1843          return True 
1844   
1845 -    def containerelements(self): 
1846          yield ('entry_tag', self.__field_entry_tag, None) 
1847          if self.entry_tag==PA_ENTRY_SOR: 
1848              yield ('pad', self.__field_pad, None) 
1849              yield ('mod_date', self.__field_mod_date, None) 
1850              yield ('zeros', self.__field_zeros, None) 
1851              yield ('index', self.__field_index, None) 
1852              yield ('pb_entry', self.__field_pb_entry, None) 
1853              yield ('street', self.__field_street, None) 
1854              yield ('city', self.__field_city, None) 
1855              yield ('state', self.__field_state, None) 
1856              yield ('zip_code', self.__field_zip_code, None) 
1857              yield ('country', self.__field_country, None) 
1858              yield ('exit_tag', self.__field_exit_tag, None) 
1859          else: 
1860              yield ('dontcare', self.__field_dontcare, None) 
1861   
1862 -    def valid(self): 
1863          global PA_ENTRY_SOR 
1864          return self.entry_tag==PA_ENTRY_SOR 
1865   
1866   
1867   
1868   
1869 -class pafile(BaseProtogenClass): 
1870      __fields=['items'] 
1871   
1872 -    def __init__(self, *args, **kwargs): 
1873          dict={} 
1874          # What was supplied to this function 
1875          dict.update(kwargs) 
1876          # Parent constructor 
1877          super(pafile,self).__init__(**dict) 
1878          if self.__class__ is pafile: 
1879              self._update(args,dict) 
1880   
1881   
1882 -    def getfields(self): 
1883          return self.__fields 
1884   
1885   
1886 -    def _update(self, args, kwargs): 
1887          super(pafile,self)._update(args,kwargs) 
1888          keys=kwargs.keys() 
1889          for key in keys: 
1890              if key in self.__fields: 
1891                  setattr(self, key, kwargs[key]) 
1892                  del kwargs[key] 
1893          # Were any unrecognized kwargs passed in? 
1894          if __debug__: 
1895              self._complainaboutunusedargs(pafile,kwargs) 
1896          if len(args): 
1897              dict2={ 'elementclass': pafileentry,             'length': NUMPHONEBOOKENTRIES,             'createdefault': True } 
1898              dict2.update(kwargs) 
1899              kwargs=dict2 
1900              self.__field_items=LIST(*args,**dict2) 
1901          # Make all P fields that haven't already been constructed 
1902   
1903   
1904 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1905          'Writes this packet to the supplied buffer' 
1906          self._bufferstartoffset=buf.getcurrentoffset() 
1907          try: self.__field_items 
1908          except: 
1909              self.__field_items=LIST(**{ 'elementclass': pafileentry,             'length': NUMPHONEBOOKENTRIES,             'createdefault': True }) 
1910          self.__field_items.writetobuffer(buf) 
1911          self._bufferendoffset=buf.getcurrentoffset() 
1912          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1913   
1914   
1915 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1916          'Reads this packet from the supplied buffer' 
1917          self._bufferstartoffset=buf.getcurrentoffset() 
1918          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1919          self.__field_items=LIST(**{ 'elementclass': pafileentry,             'length': NUMPHONEBOOKENTRIES,             'createdefault': True }) 
1920          self.__field_items.readfrombuffer(buf) 
1921          self._bufferendoffset=buf.getcurrentoffset() 
1922   
1923   
1924 -    def __getfield_items(self): 
1925          try: self.__field_items 
1926          except: 
1927              self.__field_items=LIST(**{ 'elementclass': pafileentry,             'length': NUMPHONEBOOKENTRIES,             'createdefault': True }) 
1928          return self.__field_items.getvalue() 
1929   
1930 -    def __setfield_items(self, value): 
1931          if isinstance(value,LIST): 
1932              self.__field_items=value 
1933          else: 
1934              self.__field_items=LIST(value,**{ 'elementclass': pafileentry,             'length': NUMPHONEBOOKENTRIES,             'createdefault': True }) 
1935   
1936 -    def __delfield_items(self): del self.__field_items 
1937   
1938      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
1939   
1940 -    def iscontainer(self): 
1941          return True 
1942   
1943 -    def containerelements(self): 
1944          yield ('items', self.__field_items, None) 
1945   
1946   
1947   
1948   
1949 -class pbgroup(BaseProtogenClass): 
1950      __fields=['name', 'groupid', 'user_added', 'wallpaper'] 
1951   
1952 -    def __init__(self, *args, **kwargs): 
1953          dict={} 
1954          # What was supplied to this function 
1955          dict.update(kwargs) 
1956          # Parent constructor 
1957          super(pbgroup,self).__init__(**dict) 
1958          if self.__class__ is pbgroup: 
1959              self._update(args,dict) 
1960   
1961   
1962 -    def getfields(self): 
1963          return self.__fields 
1964   
1965   
1966 -    def _update(self, args, kwargs): 
1967          super(pbgroup,self)._update(args,kwargs) 
1968          keys=kwargs.keys() 
1969          for key in keys: 
1970              if key in self.__fields: 
1971                  setattr(self, key, kwargs[key]) 
1972                  del kwargs[key] 
1973          # Were any unrecognized kwargs passed in? 
1974          if __debug__: 
1975              self._complainaboutunusedargs(pbgroup,kwargs) 
1976          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1977          # Make all P fields that haven't already been constructed 
1978   
1979   
1980 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1981          'Writes this packet to the supplied buffer' 
1982          self._bufferstartoffset=buf.getcurrentoffset() 
1983          try: self.__field_name 
1984          except: 
1985              self.__field_name=USTRING(**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING,                'raiseonunterminatedread': False,                'raiseontruncate': False,                'default': '' }) 
1986          self.__field_name.writetobuffer(buf) 
1987          try: self.__field_groupid 
1988          except: 
1989              self.__field_groupid=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1990          self.__field_groupid.writetobuffer(buf) 
1991          try: self.__field_user_added 
1992          except: 
1993              self.__field_user_added=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
1994          self.__field_user_added.writetobuffer(buf) 
1995          try: self.__field_wallpaper 
1996          except: 
1997              self.__field_wallpaper=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1998          self.__field_wallpaper.writetobuffer(buf) 
1999          self._bufferendoffset=buf.getcurrentoffset() 
2000          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2001   
2002   
2003 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2004          'Reads this packet from the supplied buffer' 
2005          self._bufferstartoffset=buf.getcurrentoffset() 
2006          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2007          self.__field_name=USTRING(**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING,                'raiseonunterminatedread': False,                'raiseontruncate': False,                'default': '' }) 
2008          self.__field_name.readfrombuffer(buf) 
2009          self.__field_groupid=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
2010          self.__field_groupid.readfrombuffer(buf) 
2011          self.__field_user_added=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
2012          self.__field_user_added.readfrombuffer(buf) 
2013          self.__field_wallpaper=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
2014          self.__field_wallpaper.readfrombuffer(buf) 
2015          self._bufferendoffset=buf.getcurrentoffset() 
2016   
2017   
2018 -    def __getfield_name(self): 
2019          try: self.__field_name 
2020          except: 
2021              self.__field_name=USTRING(**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING,                'raiseonunterminatedread': False,                'raiseontruncate': False,                'default': '' }) 
2022          return self.__field_name.getvalue() 
2023   
2024 -    def __setfield_name(self, value): 
2025          if isinstance(value,USTRING): 
2026              self.__field_name=value 
2027          else: 
2028              self.__field_name=USTRING(value,**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING,                'raiseonunterminatedread': False,                'raiseontruncate': False,                'default': '' }) 
2029   
2030 -    def __delfield_name(self): del self.__field_name 
2031   
2032      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
2033   
2034 -    def __getfield_groupid(self): 
2035          try: self.__field_groupid 
2036          except: 
2037              self.__field_groupid=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
2038          return self.__field_groupid.getvalue() 
2039   
2040 -    def __setfield_groupid(self, value): 
2041          if isinstance(value,UINT): 
2042              self.__field_groupid=value 
2043          else: 
2044              self.__field_groupid=UINT(value,**{'sizeinbytes': 2,  'default': 0 }) 
2045   
2046 -    def __delfield_groupid(self): del self.__field_groupid 
2047   
2048      groupid=property(__getfield_groupid, __setfield_groupid, __delfield_groupid, None) 
2049   
2050 -    def __getfield_user_added(self): 
2051          try: self.__field_user_added 
2052          except: 
2053              self.__field_user_added=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
2054          return self.__field_user_added.getvalue() 
2055   
2056 -    def __setfield_user_added(self, value): 
2057          if isinstance(value,UINT): 
2058              self.__field_user_added=value 
2059          else: 
2060              self.__field_user_added=UINT(value,**{'sizeinbytes': 1,  'default': 0 }) 
2061   
2062 -    def __delfield_user_added(self): del self.__field_user_added 
2063   
2064      user_added=property(__getfield_user_added, __setfield_user_added, __delfield_user_added, "=1 when was added by user") 
2065   
2066 -    def __getfield_wallpaper(self): 
2067          try: self.__field_wallpaper 
2068          except: 
2069              self.__field_wallpaper=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
2070          return self.__field_wallpaper.getvalue() 
2071   
2072 -    def __setfield_wallpaper(self, value): 
2073          if isinstance(value,UINT): 
2074              self.__field_wallpaper=value 
2075          else: 
2076              self.__field_wallpaper=UINT(value,**{'sizeinbytes': 2,  'default': 0 }) 
2077   
2078 -    def __delfield_wallpaper(self): del self.__field_wallpaper 
2079   
2080      wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None) 
2081   
2082 -    def iscontainer(self): 
2083          return True 
2084   
2085 -    def containerelements(self): 
2086          yield ('name', self.__field_name, None) 
2087          yield ('groupid', self.__field_groupid, None) 
2088          yield ('user_added', self.__field_user_added, "=1 when was added by user") 
2089          yield ('wallpaper', self.__field_wallpaper, None) 
2090   
2091   
2092   
2093   
2094 -class pbgroups(BaseProtogenClass): 
2095      "Phonebook groups" 
2096      __fields=['groups'] 
2097   
2098 -    def __init__(self, *args, **kwargs): 
2099          dict={} 
2100          # What was supplied to this function 
2101          dict.update(kwargs) 
2102          # Parent constructor 
2103          super(pbgroups,self).__init__(**dict) 
2104          if self.__class__ is pbgroups: 
2105              self._update(args,dict) 
2106   
2107   
2108 -    def getfields(self): 
2109          return self.__fields 
2110   
2111   
2112 -    def _update(self, args, kwargs): 
2113          super(pbgroups,self)._update(args,kwargs) 
2114          keys=kwargs.keys() 
2115          for key in keys: 
2116              if key in self.__fields: 
2117                  setattr(self, key, kwargs[key]) 
2118                  del kwargs[key] 
2119          # Were any unrecognized kwargs passed in? 
2120          if __debug__: 
2121              self._complainaboutunusedargs(pbgroups,kwargs) 
2122          if len(args): 
2123              dict2={'elementclass': pbgroup,            'raiseonincompleteread': False,            'length': MAX_PHONEBOOK_GROUPS,            'createdefault': True} 
2124              dict2.update(kwargs) 
2125              kwargs=dict2 
2126              self.__field_groups=LIST(*args,**dict2) 
2127          # Make all P fields that haven't already been constructed 
2128   
2129   
2130 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2131          'Writes this packet to the supplied buffer' 
2132          self._bufferstartoffset=buf.getcurrentoffset() 
2133          try: self.__field_groups 
2134          except: 
2135              self.__field_groups=LIST(**{'elementclass': pbgroup,            'raiseonincompleteread': False,            'length': MAX_PHONEBOOK_GROUPS,            'createdefault': True}) 
2136          self.__field_groups.writetobuffer(buf) 
2137          self._bufferendoffset=buf.getcurrentoffset() 
2138          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2139   
2140   
2141 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2142          'Reads this packet from the supplied buffer' 
2143          self._bufferstartoffset=buf.getcurrentoffset() 
2144          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2145          self.__field_groups=LIST(**{'elementclass': pbgroup,            'raiseonincompleteread': False,            'length': MAX_PHONEBOOK_GROUPS,            'createdefault': True}) 
2146          self.__field_groups.readfrombuffer(buf) 
2147          self._bufferendoffset=buf.getcurrentoffset() 
2148   
2149   
2150 -    def __getfield_groups(self): 
2151          try: self.__field_groups 
2152          except: 
2153              self.__field_groups=LIST(**{'elementclass': pbgroup,            'raiseonincompleteread': False,            'length': MAX_PHONEBOOK_GROUPS,            'createdefault': True}) 
2154          return self.__field_groups.getvalue() 
2155   
2156 -    def __setfield_groups(self, value): 
2157          if isinstance(value,LIST): 
2158              self.__field_groups=value 
2159          else: 
2160              self.__field_groups=LIST(value,**{'elementclass': pbgroup,            'raiseonincompleteread': False,            'length': MAX_PHONEBOOK_GROUPS,            'createdefault': True}) 
2161   
2162 -    def __delfield_groups(self): del self.__field_groups 
2163   
2164      groups=property(__getfield_groups, __setfield_groups, __delfield_groups, None) 
2165   
2166 -    def iscontainer(self): 
2167          return True 
2168   
2169 -    def containerelements(self): 
2170          yield ('groups', self.__field_groups, None) 
2171   
2172   
2173   
2174   
2175 -class favorite(BaseProtogenClass): 
2176      __fields=['pb_index', 'fav_type'] 
2177   
2178 -    def __init__(self, *args, **kwargs): 
2179          dict={} 
2180          # What was supplied to this function 
2181          dict.update(kwargs) 
2182          # Parent constructor 
2183          super(favorite,self).__init__(**dict) 
2184          if self.__class__ is favorite: 
2185              self._update(args,dict) 
2186   
2187   
2188 -    def getfields(self): 
2189          return self.__fields 
2190   
2191   
2192 -    def _update(self, args, kwargs): 
2193          super(favorite,self)._update(args,kwargs) 
2194          keys=kwargs.keys() 
2195          for key in keys: 
2196              if key in self.__fields: 
2197                  setattr(self, key, kwargs[key]) 
2198                  del kwargs[key] 
2199          # Were any unrecognized kwargs passed in? 
2200          if __debug__: 
2201              self._complainaboutunusedargs(favorite,kwargs) 
2202          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2203          # Make all P fields that haven't already been constructed 
2204   
2205   
2206 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2207          'Writes this packet to the supplied buffer' 
2208          self._bufferstartoffset=buf.getcurrentoffset() 
2209          try: self.__field_pb_index 
2210          except: 
2211              self.__field_pb_index=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
2212          self.__field_pb_index.writetobuffer(buf) 
2213          try: self.__field_fav_type 
2214          except: 
2215              self.__field_fav_type=UINT(**{'sizeinbytes': 1,  'default': 0xff }) 
2216          self.__field_fav_type.writetobuffer(buf) 
2217          self._bufferendoffset=buf.getcurrentoffset() 
2218          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2219   
2220   
2221 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2222          'Reads this packet from the supplied buffer' 
2223          self._bufferstartoffset=buf.getcurrentoffset() 
2224          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2225          self.__field_pb_index=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
2226          self.__field_pb_index.readfrombuffer(buf) 
2227          self.__field_fav_type=UINT(**{'sizeinbytes': 1,  'default': 0xff }) 
2228          self.__field_fav_type.readfrombuffer(buf) 
2229          self._bufferendoffset=buf.getcurrentoffset() 
2230   
2231   
2232 -    def __getfield_pb_index(self): 
2233          try: self.__field_pb_index 
2234          except: 
2235              self.__field_pb_index=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
2236          return self.__field_pb_index.getvalue() 
2237   
2238 -    def __setfield_pb_index(self, value): 
2239          if isinstance(value,UINT): 
2240              self.__field_pb_index=value 
2241          else: 
2242              self.__field_pb_index=UINT(value,**{'sizeinbytes': 2,  'default': 0xffff }) 
2243   
2244 -    def __delfield_pb_index(self): del self.__field_pb_index 
2245   
2246      pb_index=property(__getfield_pb_index, __setfield_pb_index, __delfield_pb_index, None) 
2247   
2248 -    def __getfield_fav_type(self): 
2249          try: self.__field_fav_type 
2250          except: 
2251              self.__field_fav_type=UINT(**{'sizeinbytes': 1,  'default': 0xff }) 
2252          return self.__field_fav_type.getvalue() 
2253   
2254 -    def __setfield_fav_type(self, value): 
2255          if isinstance(value,UINT): 
2256              self.__field_fav_type=value 
2257          else: 
2258              self.__field_fav_type=UINT(value,**{'sizeinbytes': 1,  'default': 0xff }) 
2259   
2260 -    def __delfield_fav_type(self): del self.__field_fav_type 
2261   
2262      fav_type=property(__getfield_fav_type, __setfield_fav_type, __delfield_fav_type, None) 
2263   
2264 -    def iscontainer(self): 
2265          return True 
2266   
2267 -    def containerelements(self): 
2268          yield ('pb_index', self.__field_pb_index, None) 
2269          yield ('fav_type', self.__field_fav_type, None) 
2270   
2271 -    def has_pbentry(self): 
2272          return self.pb_index != 0xffff and self.fav_type == 1 
2273   
2274   
2275   
2276   
2277 -class favorites(BaseProtogenClass): 
2278      __fields=['items'] 
2279   
2280 -    def __init__(self, *args, **kwargs): 
2281          dict={} 
2282          # What was supplied to this function 
2283          dict.update(kwargs) 
2284          # Parent constructor 
2285          super(favorites,self).__init__(**dict) 
2286          if self.__class__ is favorites: 
2287              self._update(args,dict) 
2288   
2289   
2290 -    def getfields(self): 
2291          return self.__fields 
2292   
2293   
2294 -    def _update(self, args, kwargs): 
2295          super(favorites,self)._update(args,kwargs) 
2296          keys=kwargs.keys() 
2297          for key in keys: 
2298              if key in self.__fields: 
2299                  setattr(self, key, kwargs[key]) 
2300                  del kwargs[key] 
2301          # Were any unrecognized kwargs passed in? 
2302          if __debug__: 
2303              self._complainaboutunusedargs(favorites,kwargs) 
2304          if len(args): 
2305              dict2={ 'elementclass': favorite, 'length': NUMFAVORITES } 
2306              dict2.update(kwargs) 
2307              kwargs=dict2 
2308              self.__field_items=LIST(*args,**dict2) 
2309          # Make all P fields that haven't already been constructed 
2310   
2311   
2312 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2313          'Writes this packet to the supplied buffer' 
2314          self._bufferstartoffset=buf.getcurrentoffset() 
2315          try: self.__field_items 
2316          except: 
2317              self.__field_items=LIST(**{ 'elementclass': favorite, 'length': NUMFAVORITES }) 
2318          self.__field_items.writetobuffer(buf) 
2319          self._bufferendoffset=buf.getcurrentoffset() 
2320          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2321   
2322   
2323 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2324          'Reads this packet from the supplied buffer' 
2325          self._bufferstartoffset=buf.getcurrentoffset() 
2326          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2327          self.__field_items=LIST(**{ 'elementclass': favorite, 'length': NUMFAVORITES }) 
2328          self.__field_items.readfrombuffer(buf) 
2329          self._bufferendoffset=buf.getcurrentoffset() 
2330   
2331   
2332 -    def __getfield_items(self): 
2333          try: self.__field_items 
2334          except: 
2335              self.__field_items=LIST(**{ 'elementclass': favorite, 'length': NUMFAVORITES }) 
2336          return self.__field_items.getvalue() 
2337   
2338 -    def __setfield_items(self, value): 
2339          if isinstance(value,LIST): 
2340              self.__field_items=value 
2341          else: 
2342              self.__field_items=LIST(value,**{ 'elementclass': favorite, 'length': NUMFAVORITES }) 
2343   
2344 -    def __delfield_items(self): del self.__field_items 
2345   
2346      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
2347   
2348 -    def iscontainer(self): 
2349          return True 
2350   
2351 -    def containerelements(self): 
2352          yield ('items', self.__field_items, None) 
2353   
2354 -    def set_favorite(self, index, entity_index, ispbentry): 
2355          if index < NUMFAVORITES: 
2356              self.items[index].pb_index = entity_index 
2357              if ispbentry: 
2358                  self.items[index].fav_type = 1 
2359              else: 
2360                  self.items[index].fav_type = 2 
2361   
2362   
2363   
2364   
2365 -class GroupPicID_PathIndexEntry(BaseProtogenClass): 
2366      __fields=['pathname'] 
2367   
2368 -    def __init__(self, *args, **kwargs): 
2369          dict={} 
2370          # What was supplied to this function 
2371          dict.update(kwargs) 
2372          # Parent constructor 
2373          super(GroupPicID_PathIndexEntry,self).__init__(**dict) 
2374          if self.__class__ is GroupPicID_PathIndexEntry: 
2375              self._update(args,dict) 
2376   
2377   
2378 -    def getfields(self): 
2379          return self.__fields 
2380   
2381   
2382 -    def _update(self, args, kwargs): 
2383          super(GroupPicID_PathIndexEntry,self)._update(args,kwargs) 
2384          keys=kwargs.keys() 
2385          for key in keys: 
2386              if key in self.__fields: 
2387                  setattr(self, key, kwargs[key]) 
2388                  del kwargs[key] 
2389          # Were any unrecognized kwargs passed in? 
2390          if __debug__: 
2391              self._complainaboutunusedargs(GroupPicID_PathIndexEntry,kwargs) 
2392          if len(args): 
2393              dict2={'sizeinbytes': 255,  'encoding': PHONE_ENCODING,                  'default': '' } 
2394              dict2.update(kwargs) 
2395              kwargs=dict2 
2396              self.__field_pathname=USTRING(*args,**dict2) 
2397          # Make all P fields that haven't already been constructed 
2398   
2399   
2400 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2401          'Writes this packet to the supplied buffer' 
2402          self._bufferstartoffset=buf.getcurrentoffset() 
2403          try: self.__field_pathname 
2404          except: 
2405              self.__field_pathname=USTRING(**{'sizeinbytes': 255,  'encoding': PHONE_ENCODING,                  'default': '' }) 
2406          self.__field_pathname.writetobuffer(buf) 
2407          self._bufferendoffset=buf.getcurrentoffset() 
2408          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2409   
2410   
2411 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2412          'Reads this packet from the supplied buffer' 
2413          self._bufferstartoffset=buf.getcurrentoffset() 
2414          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2415          self.__field_pathname=USTRING(**{'sizeinbytes': 255,  'encoding': PHONE_ENCODING,                  'default': '' }) 
2416          self.__field_pathname.readfrombuffer(buf) 
2417          self._bufferendoffset=buf.getcurrentoffset() 
2418   
2419   
2420 -    def __getfield_pathname(self): 
2421          try: self.__field_pathname 
2422          except: 
2423              self.__field_pathname=USTRING(**{'sizeinbytes': 255,  'encoding': PHONE_ENCODING,                  'default': '' }) 
2424          return self.__field_pathname.getvalue() 
2425   
2426 -    def __setfield_pathname(self, value): 
2427          if isinstance(value,USTRING): 
2428              self.__field_pathname=value 
2429          else: 
2430              self.__field_pathname=USTRING(value,**{'sizeinbytes': 255,  'encoding': PHONE_ENCODING,                  'default': '' }) 
2431   
2432 -    def __delfield_pathname(self): del self.__field_pathname 
2433   
2434      pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None) 
2435   
2436 -    def iscontainer(self): 
2437          return True 
2438   
2439 -    def containerelements(self): 
2440          yield ('pathname', self.__field_pathname, None) 
2441   
2442   
2443   
2444   
2445 -class GroupPicID_PathIndexFile(BaseProtogenClass): 
2446      __fields=['items'] 
2447   
2448 -    def __init__(self, *args, **kwargs): 
2449          dict={} 
2450          # What was supplied to this function 
2451          dict.update(kwargs) 
2452          # Parent constructor 
2453          super(GroupPicID_PathIndexFile,self).__init__(**dict) 
2454          if self.__class__ is GroupPicID_PathIndexFile: 
2455              self._update(args,dict) 
2456   
2457   
2458 -    def getfields(self): 
2459          return self.__fields 
2460   
2461   
2462 -    def _update(self, args, kwargs): 
2463          super(GroupPicID_PathIndexFile,self)._update(args,kwargs) 
2464          keys=kwargs.keys() 
2465          for key in keys: 
2466              if key in self.__fields: 
2467                  setattr(self, key, kwargs[key]) 
2468                  del kwargs[key] 
2469          # Were any unrecognized kwargs passed in? 
2470          if __debug__: 
2471              self._complainaboutunusedargs(GroupPicID_PathIndexFile,kwargs) 
2472          if len(args): 
2473              dict2={ 'elementclass': GroupPicID_PathIndexEntry,             'raiseonincompleteread': False,             'createdefault': True} 
2474              dict2.update(kwargs) 
2475              kwargs=dict2 
2476              self.__field_items=LIST(*args,**dict2) 
2477          # Make all P fields that haven't already been constructed 
2478   
2479   
2480 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2481          'Writes this packet to the supplied buffer' 
2482          self._bufferstartoffset=buf.getcurrentoffset() 
2483          try: self.__field_items 
2484          except: 
2485              self.__field_items=LIST(**{ 'elementclass': GroupPicID_PathIndexEntry,             'raiseonincompleteread': False,             'createdefault': True}) 
2486          self.__field_items.writetobuffer(buf) 
2487          self._bufferendoffset=buf.getcurrentoffset() 
2488          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2489   
2490   
2491 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2492          'Reads this packet from the supplied buffer' 
2493          self._bufferstartoffset=buf.getcurrentoffset() 
2494          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2495          self.__field_items=LIST(**{ 'elementclass': GroupPicID_PathIndexEntry,             'raiseonincompleteread': False,             'createdefault': True}) 
2496          self.__field_items.readfrombuffer(buf) 
2497          self._bufferendoffset=buf.getcurrentoffset() 
2498   
2499   
2500 -    def __getfield_items(self): 
2501          try: self.__field_items 
2502          except: 
2503              self.__field_items=LIST(**{ 'elementclass': GroupPicID_PathIndexEntry,             'raiseonincompleteread': False,             'createdefault': True}) 
2504          return self.__field_items.getvalue() 
2505   
2506 -    def __setfield_items(self, value): 
2507          if isinstance(value,LIST): 
2508              self.__field_items=value 
2509          else: 
2510              self.__field_items=LIST(value,**{ 'elementclass': GroupPicID_PathIndexEntry,             'raiseonincompleteread': False,             'createdefault': True}) 
2511   
2512 -    def __delfield_items(self): del self.__field_items 
2513   
2514      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
2515   
2516 -    def iscontainer(self): 
2517          return True 
2518   
2519 -    def containerelements(self): 
2520          yield ('items', self.__field_items, None) 
2521