Source Code for Module phones.p_lgax8600

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