Source Code for Module phones.p_samsungsphm300

   1  # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE 
   2  # Text in this block is placed in the output file 
   3   
   4  from prototypes import * 
   5  from prototypes_samsung import * 
   6  from p_samsung_packet import * 
   7   
   8  NUMPHONENUMBERS=5 
   9  NUMPHONEBOOKENTRIES=300 
  10  NUMGROUPS=5 
  11  MAXNUMBERLEN=32 
  12  NUMMEMOENTRIES=9 
  13  NUMTODOENTRIES=9 
  14  NUMCALENDAREVENTS=70 
  15  NUMSMSINENTRIES=211 
  16   
  17  max_pb_slots=312 
  18  max_pb_entries=312 
  19  user_pb_entry_range=xrange(1, 301) 
  20  max_number_entries=312 
  21  max_media_index_entries=302 
  22  max_group_entries=6 
  23   
  24  slot_file_name='nvm/nvm/pclink_tbl' 
  25  pb_file_name='nvm/nvm/dial_tbl' 
  26  number_file_name='nvm/nvm/dial' 
  27  ringer_index_file_name='nvm/nvm/name_ring' 
  28  wallpaper_index_file_name='nvm/nvm/avatar' 
  29  group_file_name='nvm/nvm/group' 
  30  camera_dir='cam/jpeg' 
  31  savedtophone_dir='cam/dldJpeg' 
  32   
  33  camera_index=100 # starting media index for camera images 
  34  camera_origin='camera-fullsize' 
  35  savedtophone_index=200  # starting media index for saved-to-phone images 
  36  savedtophone_origin='camera' 
  37  ams_index=300   # starting media index for AmsRegistry items 
  38   
  39  # Number type 
  40  CELLTYPE=1 
  41  HOMETYPE=2 
  42  WORKTYPE=3 
  43  PAGERTYPE=4 
  44  OTHERTYPE=5 
  45  MAILTYPE=7 
  46  URLTYPE=8 
  47   
  48  # map all UINT fields to lsb version 
  49  UINT=UINTlsb 
  50  BOOL=BOOLlsb 
  51   
  52  AMSREGISTRY="ams/AmsRegistry" 
  53  ENDTRANSACTION="ams/EndTransaction" 
  54  RINGERPREFIX="ams/Ringers/cnts" 
  55  WALLPAPERPREFIX="ams/Screen Savers/cnts" 
  56   
  57  FILETYPE_RINGER=12 
  58  FILETYPE_WALLPAPER=13 
  59  FILETYPE_APP=16 
  60  exts={ 
  61      'audio/vnd.qcelp': '.qcp', 
  62      'audio/midi': '.mid', 
  63      'application/x-pmd': '.pmd', 
  64      'audio/mpeg': '.mp3', 
  65      'image/jpeg': '.jpeg', 
  66      'image/png': '.png', 
  67      'image/gif': '.gif', 
  68      'image/bmp': '.bmp', 
  69      } 
  70   
  71  origins={ 
  72      FILETYPE_RINGER: 'ringers', 
  73      FILETYPE_WALLPAPER: 'images', 
  74      } 
  75 -class groupnameentry(BaseProtogenClass): 
  76      __fields=['gid', 'groupname', 'ringtone', 'dunno2', 'timestamp'] 
  77   
  78 -    def __init__(self, *args, **kwargs): 
  79          dict={} 
  80          # What was supplied to this function 
  81          dict.update(kwargs) 
  82          # Parent constructor 
  83          super(groupnameentry,self).__init__(**dict) 
  84          if self.__class__ is groupnameentry: 
  85              self._update(args,dict) 
  86   
  87   
  88 -    def getfields(self): 
  89          return self.__fields 
  90   
  91   
  92 -    def _update(self, args, kwargs): 
  93          super(groupnameentry,self)._update(args,kwargs) 
  94          keys=kwargs.keys() 
  95          for key in keys: 
  96              if key in self.__fields: 
  97                  setattr(self, key, kwargs[key]) 
  98                  del kwargs[key] 
  99          # Were any unrecognized kwargs passed in? 
 100          if __debug__: 
 101              self._complainaboutunusedargs(groupnameentry,kwargs) 
 102          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 103          # Make all P fields that haven't already been constructed 
 104   
 105   
 106 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 107          'Writes this packet to the supplied buffer' 
 108          self._bufferstartoffset=buf.getcurrentoffset() 
 109          self.__field_gid.writetobuffer(buf) 
 110          self.__field_groupname.writetobuffer(buf) 
 111          self.__field_ringtone.writetobuffer(buf) 
 112          self.__field_dunno2.writetobuffer(buf) 
 113          self.__field_timestamp.writetobuffer(buf) 
 114          self._bufferendoffset=buf.getcurrentoffset() 
 115          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 116   
 117   
 118 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 119          'Reads this packet from the supplied buffer' 
 120          self._bufferstartoffset=buf.getcurrentoffset() 
 121          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 122          self.__field_gid=CSVINT() 
 123          self.__field_gid.readfrombuffer(buf) 
 124          self.__field_groupname=CSVSTRING() 
 125          self.__field_groupname.readfrombuffer(buf) 
 126          self.__field_ringtone=CSVINT() 
 127          self.__field_ringtone.readfrombuffer(buf) 
 128          self.__field_dunno2=CSVSTRING(**{'quotechar': None}) 
 129          self.__field_dunno2.readfrombuffer(buf) 
 130          self.__field_timestamp=CSVTIME(**{'terminator': None}) 
 131          self.__field_timestamp.readfrombuffer(buf) 
 132          self._bufferendoffset=buf.getcurrentoffset() 
 133   
 134   
 135 -    def __getfield_gid(self): 
 136          return self.__field_gid.getvalue() 
 137   
 138 -    def __setfield_gid(self, value): 
 139          if isinstance(value,CSVINT): 
 140              self.__field_gid=value 
 141          else: 
 142              self.__field_gid=CSVINT(value,) 
 143   
 144 -    def __delfield_gid(self): del self.__field_gid 
 145   
 146      gid=property(__getfield_gid, __setfield_gid, __delfield_gid, None) 
 147   
 148 -    def __getfield_groupname(self): 
 149          return self.__field_groupname.getvalue() 
 150   
 151 -    def __setfield_groupname(self, value): 
 152          if isinstance(value,CSVSTRING): 
 153              self.__field_groupname=value 
 154          else: 
 155              self.__field_groupname=CSVSTRING(value,) 
 156   
 157 -    def __delfield_groupname(self): del self.__field_groupname 
 158   
 159      groupname=property(__getfield_groupname, __setfield_groupname, __delfield_groupname, None) 
 160   
 161 -    def __getfield_ringtone(self): 
 162          return self.__field_ringtone.getvalue() 
 163   
 164 -    def __setfield_ringtone(self, value): 
 165          if isinstance(value,CSVINT): 
 166              self.__field_ringtone=value 
 167          else: 
 168              self.__field_ringtone=CSVINT(value,) 
 169   
 170 -    def __delfield_ringtone(self): del self.__field_ringtone 
 171   
 172      ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, "Ringtone assignment?") 
 173   
 174 -    def __getfield_dunno2(self): 
 175          return self.__field_dunno2.getvalue() 
 176   
 177 -    def __setfield_dunno2(self, value): 
 178          if isinstance(value,CSVSTRING): 
 179              self.__field_dunno2=value 
 180          else: 
 181              self.__field_dunno2=CSVSTRING(value,**{'quotechar': None}) 
 182   
 183 -    def __delfield_dunno2(self): del self.__field_dunno2 
 184   
 185      dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, "A single character C or S") 
 186   
 187 -    def __getfield_timestamp(self): 
 188          return self.__field_timestamp.getvalue() 
 189   
 190 -    def __setfield_timestamp(self, value): 
 191          if isinstance(value,CSVTIME): 
 192              self.__field_timestamp=value 
 193          else: 
 194              self.__field_timestamp=CSVTIME(value,**{'terminator': None}) 
 195   
 196 -    def __delfield_timestamp(self): del self.__field_timestamp 
 197   
 198      timestamp=property(__getfield_timestamp, __setfield_timestamp, __delfield_timestamp, None) 
 199   
 200 -    def iscontainer(self): 
 201          return True 
 202   
 203 -    def containerelements(self): 
 204          yield ('gid', self.__field_gid, None) 
 205          yield ('groupname', self.__field_groupname, None) 
 206          yield ('ringtone', self.__field_ringtone, "Ringtone assignment?") 
 207          yield ('dunno2', self.__field_dunno2, "A single character C or S") 
 208          yield ('timestamp', self.__field_timestamp, None) 
 209   
 210   
 211   
 212   
 213 -class groupnameresponse(BaseProtogenClass): 
 214      __fields=['command', 'entry'] 
 215   
 216 -    def __init__(self, *args, **kwargs): 
 217          dict={} 
 218          # What was supplied to this function 
 219          dict.update(kwargs) 
 220          # Parent constructor 
 221          super(groupnameresponse,self).__init__(**dict) 
 222          if self.__class__ is groupnameresponse: 
 223              self._update(args,dict) 
 224   
 225   
 226 -    def getfields(self): 
 227          return self.__fields 
 228   
 229   
 230 -    def _update(self, args, kwargs): 
 231          super(groupnameresponse,self)._update(args,kwargs) 
 232          keys=kwargs.keys() 
 233          for key in keys: 
 234              if key in self.__fields: 
 235                  setattr(self, key, kwargs[key]) 
 236                  del kwargs[key] 
 237          # Were any unrecognized kwargs passed in? 
 238          if __debug__: 
 239              self._complainaboutunusedargs(groupnameresponse,kwargs) 
 240          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 241          # Make all P fields that haven't already been constructed 
 242   
 243   
 244 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 245          'Writes this packet to the supplied buffer' 
 246          self._bufferstartoffset=buf.getcurrentoffset() 
 247          self.__field_command.writetobuffer(buf) 
 248          self.__field_entry.writetobuffer(buf) 
 249          self._bufferendoffset=buf.getcurrentoffset() 
 250          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 251   
 252   
 253 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 254          'Reads this packet from the supplied buffer' 
 255          self._bufferstartoffset=buf.getcurrentoffset() 
 256          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 257          self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': ord(' '), 'constant': '#PBGRR:'}) 
 258          self.__field_command.readfrombuffer(buf) 
 259          self.__field_entry=groupnameentry() 
 260          self.__field_entry.readfrombuffer(buf) 
 261          self._bufferendoffset=buf.getcurrentoffset() 
 262   
 263   
 264 -    def __getfield_command(self): 
 265          return self.__field_command.getvalue() 
 266   
 267 -    def __setfield_command(self, value): 
 268          if isinstance(value,CSVSTRING): 
 269              self.__field_command=value 
 270          else: 
 271              self.__field_command=CSVSTRING(value,**{'quotechar': None, 'terminator': ord(' '), 'constant': '#PBGRR:'}) 
 272   
 273 -    def __delfield_command(self): del self.__field_command 
 274   
 275      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
 276   
 277 -    def __getfield_entry(self): 
 278          return self.__field_entry.getvalue() 
 279   
 280 -    def __setfield_entry(self, value): 
 281          if isinstance(value,groupnameentry): 
 282              self.__field_entry=value 
 283          else: 
 284              self.__field_entry=groupnameentry(value,) 
 285   
 286 -    def __delfield_entry(self): del self.__field_entry 
 287   
 288      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
 289   
 290 -    def iscontainer(self): 
 291          return True 
 292   
 293 -    def containerelements(self): 
 294          yield ('command', self.__field_command, None) 
 295          yield ('entry', self.__field_entry, None) 
 296   
 297   
 298   
 299   
 300 -class pbentry(BaseProtogenClass): 
 301      __fields=['writeflg', 'slot', 'uslot', 'group', 'ringtone', 'name', 'speeddial', 'dunno1', 'numbers', 'extranumber', 'dunno3', 'dunno4', 'email', 'url', 'birthday', 'wallpaper', 'timestamp'] 
 302   
 303 -    def __init__(self, *args, **kwargs): 
 304          dict={} 
 305          # What was supplied to this function 
 306          dict.update(kwargs) 
 307          # Parent constructor 
 308          super(pbentry,self).__init__(**dict) 
 309          if self.__class__ is pbentry: 
 310              self._update(args,dict) 
 311   
 312   
 313 -    def getfields(self): 
 314          return self.__fields 
 315   
 316   
 317 -    def _update(self, args, kwargs): 
 318          super(pbentry,self)._update(args,kwargs) 
 319          keys=kwargs.keys() 
 320          for key in keys: 
 321              if key in self.__fields: 
 322                  setattr(self, key, kwargs[key]) 
 323                  del kwargs[key] 
 324          # Were any unrecognized kwargs passed in? 
 325          if __debug__: 
 326              self._complainaboutunusedargs(pbentry,kwargs) 
 327          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 328          # Make all P fields that haven't already been constructed 
 329          try: self.__field_writeflg 
 330          except: 
 331              self.__field_writeflg=BOOL(**{ 'default': False }) 
 332   
 333   
 334 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 335          'Writes this packet to the supplied buffer' 
 336          self._bufferstartoffset=buf.getcurrentoffset() 
 337          self.__field_slot.writetobuffer(buf) 
 338          self.__field_uslot.writetobuffer(buf) 
 339          self.__field_group.writetobuffer(buf) 
 340          try: self.__field_ringtone 
 341          except: 
 342              self.__field_ringtone=CSVINT(**{'default': 20}) 
 343          self.__field_ringtone.writetobuffer(buf) 
 344          self.__field_name.writetobuffer(buf) 
 345          self.__field_speeddial.writetobuffer(buf) 
 346          try: self.__field_dunno1 
 347          except: 
 348              self.__field_dunno1=CSVINT(**{'default': 0}) 
 349          self.__field_dunno1.writetobuffer(buf) 
 350          try: self.__field_numbers 
 351          except: 
 352              self.__field_numbers=LIST(**{'length': NUMPHONENUMBERS, 'createdefault': True, 'elementclass': phonenumber}) 
 353          self.__field_numbers.writetobuffer(buf) 
 354          if self.writeflg: 
 355              try: self.__field_extranumber 
 356              except: 
 357                  self.__field_extranumber=phonenumber() 
 358              self.__field_extranumber.writetobuffer(buf) 
 359          try: self.__field_dunno3 
 360          except: 
 361              self.__field_dunno3=CSVSTRING(**{'quotechar': None, 'default': ""}) 
 362          self.__field_dunno3.writetobuffer(buf) 
 363          try: self.__field_dunno4 
 364          except: 
 365              self.__field_dunno4=CSVSTRING(**{'quotechar': None, 'default': ""}) 
 366          self.__field_dunno4.writetobuffer(buf) 
 367          self.__field_email.writetobuffer(buf) 
 368          self.__field_url.writetobuffer(buf) 
 369          try: self.__field_birthday 
 370          except: 
 371              self.__field_birthday=CSVSTRING(**{'quotechar': None, 'default': ""}) 
 372          self.__field_birthday.writetobuffer(buf) 
 373          try: self.__field_wallpaper 
 374          except: 
 375              self.__field_wallpaper=CSVINT(**{'default': 20}) 
 376          self.__field_wallpaper.writetobuffer(buf) 
 377          try: self.__field_timestamp 
 378          except: 
 379              self.__field_timestamp=CSVTIME(**{'terminator': None,               'default': DateTime.now()+(0,) }) 
 380          self.__field_timestamp.writetobuffer(buf) 
 381          self._bufferendoffset=buf.getcurrentoffset() 
 382          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 383   
 384   
 385 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 386          'Reads this packet from the supplied buffer' 
 387          self._bufferstartoffset=buf.getcurrentoffset() 
 388          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 389          self.__field_slot=CSVINT() 
 390          self.__field_slot.readfrombuffer(buf) 
 391          self.__field_uslot=CSVINT() 
 392          self.__field_uslot.readfrombuffer(buf) 
 393          self.__field_group=CSVINT() 
 394          self.__field_group.readfrombuffer(buf) 
 395          self.__field_ringtone=CSVINT(**{'default': 20}) 
 396          self.__field_ringtone.readfrombuffer(buf) 
 397          self.__field_name=CSVSTRING() 
 398          self.__field_name.readfrombuffer(buf) 
 399          self.__field_speeddial=CSVINT() 
 400          self.__field_speeddial.readfrombuffer(buf) 
 401          self.__field_dunno1=CSVINT(**{'default': 0}) 
 402          self.__field_dunno1.readfrombuffer(buf) 
 403          self.__field_numbers=LIST(**{'length': NUMPHONENUMBERS, 'createdefault': True, 'elementclass': phonenumber}) 
 404          self.__field_numbers.readfrombuffer(buf) 
 405          if self.writeflg: 
 406              self.__field_extranumber=phonenumber() 
 407              self.__field_extranumber.readfrombuffer(buf) 
 408          self.__field_dunno3=CSVSTRING(**{'quotechar': None, 'default': ""}) 
 409          self.__field_dunno3.readfrombuffer(buf) 
 410          self.__field_dunno4=CSVSTRING(**{'quotechar': None, 'default': ""}) 
 411          self.__field_dunno4.readfrombuffer(buf) 
 412          self.__field_email=CSVSTRING() 
 413          self.__field_email.readfrombuffer(buf) 
 414          self.__field_url=CSVSTRING() 
 415          self.__field_url.readfrombuffer(buf) 
 416          self.__field_birthday=CSVSTRING(**{'quotechar': None, 'default': ""}) 
 417          self.__field_birthday.readfrombuffer(buf) 
 418          self.__field_wallpaper=CSVINT(**{'default': 20}) 
 419          self.__field_wallpaper.readfrombuffer(buf) 
 420          self.__field_timestamp=CSVTIME(**{'terminator': None,               'default': DateTime.now()+(0,) }) 
 421          self.__field_timestamp.readfrombuffer(buf) 
 422          self._bufferendoffset=buf.getcurrentoffset() 
 423   
 424   
 425 -    def __getfield_writeflg(self): 
 426          try: self.__field_writeflg 
 427          except: 
 428              self.__field_writeflg=BOOL(**{ 'default': False }) 
 429          return self.__field_writeflg.getvalue() 
 430   
 431 -    def __setfield_writeflg(self, value): 
 432          if isinstance(value,BOOL): 
 433              self.__field_writeflg=value 
 434          else: 
 435              self.__field_writeflg=BOOL(value,**{ 'default': False }) 
 436   
 437 -    def __delfield_writeflg(self): del self.__field_writeflg 
 438   
 439      writeflg=property(__getfield_writeflg, __setfield_writeflg, __delfield_writeflg, "Set to True when writing to phone") 
 440   
 441 -    def __getfield_slot(self): 
 442          return self.__field_slot.getvalue() 
 443   
 444 -    def __setfield_slot(self, value): 
 445          if isinstance(value,CSVINT): 
 446              self.__field_slot=value 
 447          else: 
 448              self.__field_slot=CSVINT(value,) 
 449   
 450 -    def __delfield_slot(self): del self.__field_slot 
 451   
 452      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, "Internal Slot") 
 453   
 454 -    def __getfield_uslot(self): 
 455          return self.__field_uslot.getvalue() 
 456   
 457 -    def __setfield_uslot(self, value): 
 458          if isinstance(value,CSVINT): 
 459              self.__field_uslot=value 
 460          else: 
 461              self.__field_uslot=CSVINT(value,) 
 462   
 463 -    def __delfield_uslot(self): del self.__field_uslot 
 464   
 465      uslot=property(__getfield_uslot, __setfield_uslot, __delfield_uslot, "User Slot, Speed dial") 
 466   
 467 -    def __getfield_group(self): 
 468          return self.__field_group.getvalue() 
 469   
 470 -    def __setfield_group(self, value): 
 471          if isinstance(value,CSVINT): 
 472              self.__field_group=value 
 473          else: 
 474              self.__field_group=CSVINT(value,) 
 475   
 476 -    def __delfield_group(self): del self.__field_group 
 477   
 478      group=property(__getfield_group, __setfield_group, __delfield_group, None) 
 479   
 480 -    def __getfield_ringtone(self): 
 481          try: self.__field_ringtone 
 482          except: 
 483              self.__field_ringtone=CSVINT(**{'default': 20}) 
 484          return self.__field_ringtone.getvalue() 
 485   
 486 -    def __setfield_ringtone(self, value): 
 487          if isinstance(value,CSVINT): 
 488              self.__field_ringtone=value 
 489          else: 
 490              self.__field_ringtone=CSVINT(value,**{'default': 20}) 
 491   
 492 -    def __delfield_ringtone(self): del self.__field_ringtone 
 493   
 494      ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 
 495   
 496 -    def __getfield_name(self): 
 497          return self.__field_name.getvalue() 
 498   
 499 -    def __setfield_name(self, value): 
 500          if isinstance(value,CSVSTRING): 
 501              self.__field_name=value 
 502          else: 
 503              self.__field_name=CSVSTRING(value,) 
 504   
 505 -    def __delfield_name(self): del self.__field_name 
 506   
 507      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
 508   
 509 -    def __getfield_speeddial(self): 
 510          return self.__field_speeddial.getvalue() 
 511   
 512 -    def __setfield_speeddial(self, value): 
 513          if isinstance(value,CSVINT): 
 514              self.__field_speeddial=value 
 515          else: 
 516              self.__field_speeddial=CSVINT(value,) 
 517   
 518 -    def __delfield_speeddial(self): del self.__field_speeddial 
 519   
 520      speeddial=property(__getfield_speeddial, __setfield_speeddial, __delfield_speeddial, "Which phone number assigned to speed dial uslot") 
 521   
 522 -    def __getfield_dunno1(self): 
 523          try: self.__field_dunno1 
 524          except: 
 525              self.__field_dunno1=CSVINT(**{'default': 0}) 
 526          return self.__field_dunno1.getvalue() 
 527   
 528 -    def __setfield_dunno1(self, value): 
 529          if isinstance(value,CSVINT): 
 530              self.__field_dunno1=value 
 531          else: 
 532              self.__field_dunno1=CSVINT(value,**{'default': 0}) 
 533   
 534 -    def __delfield_dunno1(self): del self.__field_dunno1 
 535   
 536      dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None) 
 537   
 538 -    def __getfield_numbers(self): 
 539          try: self.__field_numbers 
 540          except: 
 541              self.__field_numbers=LIST(**{'length': NUMPHONENUMBERS, 'createdefault': True, 'elementclass': phonenumber}) 
 542          return self.__field_numbers.getvalue() 
 543   
 544 -    def __setfield_numbers(self, value): 
 545          if isinstance(value,LIST): 
 546              self.__field_numbers=value 
 547          else: 
 548              self.__field_numbers=LIST(value,**{'length': NUMPHONENUMBERS, 'createdefault': True, 'elementclass': phonenumber}) 
 549   
 550 -    def __delfield_numbers(self): del self.__field_numbers 
 551   
 552      numbers=property(__getfield_numbers, __setfield_numbers, __delfield_numbers, None) 
 553   
 554 -    def __getfield_extranumber(self): 
 555          try: self.__field_extranumber 
 556          except: 
 557              self.__field_extranumber=phonenumber() 
 558          return self.__field_extranumber.getvalue() 
 559   
 560 -    def __setfield_extranumber(self, value): 
 561          if isinstance(value,phonenumber): 
 562              self.__field_extranumber=value 
 563          else: 
 564              self.__field_extranumber=phonenumber(value,) 
 565   
 566 -    def __delfield_extranumber(self): del self.__field_extranumber 
 567   
 568      extranumber=property(__getfield_extranumber, __setfield_extranumber, __delfield_extranumber, None) 
 569   
 570 -    def __getfield_dunno3(self): 
 571          try: self.__field_dunno3 
 572          except: 
 573              self.__field_dunno3=CSVSTRING(**{'quotechar': None, 'default': ""}) 
 574          return self.__field_dunno3.getvalue() 
 575   
 576 -    def __setfield_dunno3(self, value): 
 577          if isinstance(value,CSVSTRING): 
 578              self.__field_dunno3=value 
 579          else: 
 580              self.__field_dunno3=CSVSTRING(value,**{'quotechar': None, 'default': ""}) 
 581   
 582 -    def __delfield_dunno3(self): del self.__field_dunno3 
 583   
 584      dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None) 
 585   
 586 -    def __getfield_dunno4(self): 
 587          try: self.__field_dunno4 
 588          except: 
 589              self.__field_dunno4=CSVSTRING(**{'quotechar': None, 'default': ""}) 
 590          return self.__field_dunno4.getvalue() 
 591   
 592 -    def __setfield_dunno4(self, value): 
 593          if isinstance(value,CSVSTRING): 
 594              self.__field_dunno4=value 
 595          else: 
 596              self.__field_dunno4=CSVSTRING(value,**{'quotechar': None, 'default': ""}) 
 597   
 598 -    def __delfield_dunno4(self): del self.__field_dunno4 
 599   
 600      dunno4=property(__getfield_dunno4, __setfield_dunno4, __delfield_dunno4, None) 
 601   
 602 -    def __getfield_email(self): 
 603          return self.__field_email.getvalue() 
 604   
 605 -    def __setfield_email(self, value): 
 606          if isinstance(value,CSVSTRING): 
 607              self.__field_email=value 
 608          else: 
 609              self.__field_email=CSVSTRING(value,) 
 610   
 611 -    def __delfield_email(self): del self.__field_email 
 612   
 613      email=property(__getfield_email, __setfield_email, __delfield_email, None) 
 614   
 615 -    def __getfield_url(self): 
 616          return self.__field_url.getvalue() 
 617   
 618 -    def __setfield_url(self, value): 
 619          if isinstance(value,CSVSTRING): 
 620              self.__field_url=value 
 621          else: 
 622              self.__field_url=CSVSTRING(value,) 
 623   
 624 -    def __delfield_url(self): del self.__field_url 
 625   
 626      url=property(__getfield_url, __setfield_url, __delfield_url, None) 
 627   
 628 -    def __getfield_birthday(self): 
 629          try: self.__field_birthday 
 630          except: 
 631              self.__field_birthday=CSVSTRING(**{'quotechar': None, 'default': ""}) 
 632          return self.__field_birthday.getvalue() 
 633   
 634 -    def __setfield_birthday(self, value): 
 635          if isinstance(value,CSVSTRING): 
 636              self.__field_birthday=value 
 637          else: 
 638              self.__field_birthday=CSVSTRING(value,**{'quotechar': None, 'default': ""}) 
 639   
 640 -    def __delfield_birthday(self): del self.__field_birthday 
 641   
 642      birthday=property(__getfield_birthday, __setfield_birthday, __delfield_birthday, None) 
 643   
 644 -    def __getfield_wallpaper(self): 
 645          try: self.__field_wallpaper 
 646          except: 
 647              self.__field_wallpaper=CSVINT(**{'default': 20}) 
 648          return self.__field_wallpaper.getvalue() 
 649   
 650 -    def __setfield_wallpaper(self, value): 
 651          if isinstance(value,CSVINT): 
 652              self.__field_wallpaper=value 
 653          else: 
 654              self.__field_wallpaper=CSVINT(value,**{'default': 20}) 
 655   
 656 -    def __delfield_wallpaper(self): del self.__field_wallpaper 
 657   
 658      wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None) 
 659   
 660 -    def __getfield_timestamp(self): 
 661          try: self.__field_timestamp 
 662          except: 
 663              self.__field_timestamp=CSVTIME(**{'terminator': None,               'default': DateTime.now()+(0,) }) 
 664          return self.__field_timestamp.getvalue() 
 665   
 666 -    def __setfield_timestamp(self, value): 
 667          if isinstance(value,CSVTIME): 
 668              self.__field_timestamp=value 
 669          else: 
 670              self.__field_timestamp=CSVTIME(value,**{'terminator': None,               'default': DateTime.now()+(0,) }) 
 671   
 672 -    def __delfield_timestamp(self): del self.__field_timestamp 
 673   
 674      timestamp=property(__getfield_timestamp, __setfield_timestamp, __delfield_timestamp, "Use terminator None for last item") 
 675   
 676 -    def iscontainer(self): 
 677          return True 
 678   
 679 -    def containerelements(self): 
 680          yield ('writeflg', self.__field_writeflg, "Set to True when writing to phone") 
 681          yield ('slot', self.__field_slot, "Internal Slot") 
 682          yield ('uslot', self.__field_uslot, "User Slot, Speed dial") 
 683          yield ('group', self.__field_group, None) 
 684          yield ('ringtone', self.__field_ringtone, None) 
 685          yield ('name', self.__field_name, None) 
 686          yield ('speeddial', self.__field_speeddial, "Which phone number assigned to speed dial uslot") 
 687          yield ('dunno1', self.__field_dunno1, None) 
 688          yield ('numbers', self.__field_numbers, None) 
 689          if self.writeflg: 
 690              yield ('extranumber', self.__field_extranumber, None) 
 691          yield ('dunno3', self.__field_dunno3, None) 
 692          yield ('dunno4', self.__field_dunno4, None) 
 693          yield ('email', self.__field_email, None) 
 694          yield ('url', self.__field_url, None) 
 695          yield ('birthday', self.__field_birthday, None) 
 696          yield ('wallpaper', self.__field_wallpaper, None) 
 697          yield ('timestamp', self.__field_timestamp, "Use terminator None for last item") 
 698   
 699   
 700   
 701   
 702 -class phonebookslotresponse(BaseProtogenClass): 
 703      __fields=['command', 'entry'] 
 704   
 705 -    def __init__(self, *args, **kwargs): 
 706          dict={} 
 707          # What was supplied to this function 
 708          dict.update(kwargs) 
 709          # Parent constructor 
 710          super(phonebookslotresponse,self).__init__(**dict) 
 711          if self.__class__ is phonebookslotresponse: 
 712              self._update(args,dict) 
 713   
 714   
 715 -    def getfields(self): 
 716          return self.__fields 
 717   
 718   
 719 -    def _update(self, args, kwargs): 
 720          super(phonebookslotresponse,self)._update(args,kwargs) 
 721          keys=kwargs.keys() 
 722          for key in keys: 
 723              if key in self.__fields: 
 724                  setattr(self, key, kwargs[key]) 
 725                  del kwargs[key] 
 726          # Were any unrecognized kwargs passed in? 
 727          if __debug__: 
 728              self._complainaboutunusedargs(phonebookslotresponse,kwargs) 
 729          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 730          # Make all P fields that haven't already been constructed 
 731   
 732   
 733 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 734          'Writes this packet to the supplied buffer' 
 735          self._bufferstartoffset=buf.getcurrentoffset() 
 736          self.__field_command.writetobuffer(buf) 
 737          self.__field_entry.writetobuffer(buf) 
 738          self._bufferendoffset=buf.getcurrentoffset() 
 739          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 740   
 741   
 742 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 743          'Reads this packet from the supplied buffer' 
 744          self._bufferstartoffset=buf.getcurrentoffset() 
 745          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 746          self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': ord(' '), 'constant': '#PBOKR:'}) 
 747          self.__field_command.readfrombuffer(buf) 
 748          self.__field_entry=pbentry() 
 749          self.__field_entry.readfrombuffer(buf) 
 750          self._bufferendoffset=buf.getcurrentoffset() 
 751   
 752   
 753 -    def __getfield_command(self): 
 754          return self.__field_command.getvalue() 
 755   
 756 -    def __setfield_command(self, value): 
 757          if isinstance(value,CSVSTRING): 
 758              self.__field_command=value 
 759          else: 
 760              self.__field_command=CSVSTRING(value,**{'quotechar': None, 'terminator': ord(' '), 'constant': '#PBOKR:'}) 
 761   
 762 -    def __delfield_command(self): del self.__field_command 
 763   
 764      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
 765   
 766 -    def __getfield_entry(self): 
 767          return self.__field_entry.getvalue() 
 768   
 769 -    def __setfield_entry(self, value): 
 770          if isinstance(value,pbentry): 
 771              self.__field_entry=value 
 772          else: 
 773              self.__field_entry=pbentry(value,) 
 774   
 775 -    def __delfield_entry(self): del self.__field_entry 
 776   
 777      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
 778   
 779 -    def iscontainer(self): 
 780          return True 
 781   
 782 -    def containerelements(self): 
 783          yield ('command', self.__field_command, None) 
 784          yield ('entry', self.__field_entry, None) 
 785   
 786   
 787   
 788   
 789 -class phonebookslotupdaterequest(BaseProtogenClass): 
 790      __fields=['command', 'entry'] 
 791   
 792 -    def __init__(self, *args, **kwargs): 
 793          dict={} 
 794          # What was supplied to this function 
 795          dict.update(kwargs) 
 796          # Parent constructor 
 797          super(phonebookslotupdaterequest,self).__init__(**dict) 
 798          if self.__class__ is phonebookslotupdaterequest: 
 799              self._update(args,dict) 
 800   
 801   
 802 -    def getfields(self): 
 803          return self.__fields 
 804   
 805   
 806 -    def _update(self, args, kwargs): 
 807          super(phonebookslotupdaterequest,self)._update(args,kwargs) 
 808          keys=kwargs.keys() 
 809          for key in keys: 
 810              if key in self.__fields: 
 811                  setattr(self, key, kwargs[key]) 
 812                  del kwargs[key] 
 813          # Were any unrecognized kwargs passed in? 
 814          if __debug__: 
 815              self._complainaboutunusedargs(phonebookslotupdaterequest,kwargs) 
 816          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 817          # Make all P fields that haven't already been constructed 
 818   
 819   
 820 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 821          'Writes this packet to the supplied buffer' 
 822          self._bufferstartoffset=buf.getcurrentoffset() 
 823          try: self.__field_command 
 824          except: 
 825              self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PBOKW=0,'}) 
 826          self.__field_command.writetobuffer(buf) 
 827          self.__field_entry.writetobuffer(buf) 
 828          self._bufferendoffset=buf.getcurrentoffset() 
 829          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 830   
 831   
 832 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 833          'Reads this packet from the supplied buffer' 
 834          self._bufferstartoffset=buf.getcurrentoffset() 
 835          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 836          self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PBOKW=0,'}) 
 837          self.__field_command.readfrombuffer(buf) 
 838          self.__field_entry=pbentry() 
 839          self.__field_entry.readfrombuffer(buf) 
 840          self._bufferendoffset=buf.getcurrentoffset() 
 841   
 842   
 843 -    def __getfield_command(self): 
 844          try: self.__field_command 
 845          except: 
 846              self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PBOKW=0,'}) 
 847          return self.__field_command.getvalue() 
 848   
 849 -    def __setfield_command(self, value): 
 850          if isinstance(value,CSVSTRING): 
 851              self.__field_command=value 
 852          else: 
 853              self.__field_command=CSVSTRING(value,**{'quotechar': None, 'terminator': None, 'default': '#PBOKW=0,'}) 
 854   
 855 -    def __delfield_command(self): del self.__field_command 
 856   
 857      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
 858   
 859 -    def __getfield_entry(self): 
 860          return self.__field_entry.getvalue() 
 861   
 862 -    def __setfield_entry(self, value): 
 863          if isinstance(value,pbentry): 
 864              self.__field_entry=value 
 865          else: 
 866              self.__field_entry=pbentry(value,) 
 867   
 868 -    def __delfield_entry(self): del self.__field_entry 
 869   
 870      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
 871   
 872 -    def iscontainer(self): 
 873          return True 
 874   
 875 -    def containerelements(self): 
 876          yield ('command', self.__field_command, None) 
 877          yield ('entry', self.__field_entry, None) 
 878   
 879   
 880   
 881   
 882 -class smsinrequest(BaseProtogenClass): 
 883      __fields=['command', 'slot'] 
 884   
 885 -    def __init__(self, *args, **kwargs): 
 886          dict={} 
 887          # What was supplied to this function 
 888          dict.update(kwargs) 
 889          # Parent constructor 
 890          super(smsinrequest,self).__init__(**dict) 
 891          if self.__class__ is smsinrequest: 
 892              self._update(args,dict) 
 893   
 894   
 895 -    def getfields(self): 
 896          return self.__fields 
 897   
 898   
 899 -    def _update(self, args, kwargs): 
 900          super(smsinrequest,self)._update(args,kwargs) 
 901          keys=kwargs.keys() 
 902          for key in keys: 
 903              if key in self.__fields: 
 904                  setattr(self, key, kwargs[key]) 
 905                  del kwargs[key] 
 906          # Were any unrecognized kwargs passed in? 
 907          if __debug__: 
 908              self._complainaboutunusedargs(smsinrequest,kwargs) 
 909          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 910          # Make all P fields that haven't already been constructed 
 911   
 912   
 913 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 914          'Writes this packet to the supplied buffer' 
 915          self._bufferstartoffset=buf.getcurrentoffset() 
 916          try: self.__field_command 
 917          except: 
 918              self.__field_command=CSVSTRING(**{'quotechar': None,                 'terminator': None,                 'default': '#PSRMR='}) 
 919          self.__field_command.writetobuffer(buf) 
 920          self.__field_slot.writetobuffer(buf) 
 921          self._bufferendoffset=buf.getcurrentoffset() 
 922          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 923   
 924   
 925 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 926          'Reads this packet from the supplied buffer' 
 927          self._bufferstartoffset=buf.getcurrentoffset() 
 928          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 929          self.__field_command=CSVSTRING(**{'quotechar': None,                 'terminator': None,                 'default': '#PSRMR='}) 
 930          self.__field_command.readfrombuffer(buf) 
 931          self.__field_slot=CSVINT(**{'terminator': None}) 
 932          self.__field_slot.readfrombuffer(buf) 
 933          self._bufferendoffset=buf.getcurrentoffset() 
 934   
 935   
 936 -    def __getfield_command(self): 
 937          try: self.__field_command 
 938          except: 
 939              self.__field_command=CSVSTRING(**{'quotechar': None,                 'terminator': None,                 'default': '#PSRMR='}) 
 940          return self.__field_command.getvalue() 
 941   
 942 -    def __setfield_command(self, value): 
 943          if isinstance(value,CSVSTRING): 
 944              self.__field_command=value 
 945          else: 
 946              self.__field_command=CSVSTRING(value,**{'quotechar': None,                 'terminator': None,                 'default': '#PSRMR='}) 
 947   
 948 -    def __delfield_command(self): del self.__field_command 
 949   
 950      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
 951   
 952 -    def __getfield_slot(self): 
 953          return self.__field_slot.getvalue() 
 954   
 955 -    def __setfield_slot(self, value): 
 956          if isinstance(value,CSVINT): 
 957              self.__field_slot=value 
 958          else: 
 959              self.__field_slot=CSVINT(value,**{'terminator': None}) 
 960   
 961 -    def __delfield_slot(self): del self.__field_slot 
 962   
 963      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
 964   
 965 -    def iscontainer(self): 
 966          return True 
 967   
 968 -    def containerelements(self): 
 969          yield ('command', self.__field_command, None) 
 970          yield ('slot', self.__field_slot, None) 
 971   
 972   
 973   
 974   
 975 -class smsinresponse(BaseProtogenClass): 
 976      __fields=['bytes'] 
 977   
 978 -    def __init__(self, *args, **kwargs): 
 979          dict={} 
 980          # What was supplied to this function 
 981          dict.update(kwargs) 
 982          # Parent constructor 
 983          super(smsinresponse,self).__init__(**dict) 
 984          if self.__class__ is smsinresponse: 
 985              self._update(args,dict) 
 986   
 987   
 988 -    def getfields(self): 
 989          return self.__fields 
 990   
 991   
 992 -    def _update(self, args, kwargs): 
 993          super(smsinresponse,self)._update(args,kwargs) 
 994          keys=kwargs.keys() 
 995          for key in keys: 
 996              if key in self.__fields: 
 997                  setattr(self, key, kwargs[key]) 
 998                  del kwargs[key] 
 999          # Were any unrecognized kwargs passed in? 
1000          if __debug__: 
1001              self._complainaboutunusedargs(smsinresponse,kwargs) 
1002          if len(args): 
1003              dict2={} 
1004              dict2.update(kwargs) 
1005              kwargs=dict2 
1006              self.__field_bytes=DATA(*args,**dict2) 
1007          # Make all P fields that haven't already been constructed 
1008   
1009   
1010 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1011          'Writes this packet to the supplied buffer' 
1012          self._bufferstartoffset=buf.getcurrentoffset() 
1013          self.__field_bytes.writetobuffer(buf) 
1014          self._bufferendoffset=buf.getcurrentoffset() 
1015          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1016   
1017   
1018 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1019          'Reads this packet from the supplied buffer' 
1020          self._bufferstartoffset=buf.getcurrentoffset() 
1021          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1022          self.__field_bytes=DATA() 
1023          self.__field_bytes.readfrombuffer(buf) 
1024          self._bufferendoffset=buf.getcurrentoffset() 
1025   
1026   
1027 -    def __getfield_bytes(self): 
1028          return self.__field_bytes.getvalue() 
1029   
1030 -    def __setfield_bytes(self, value): 
1031          if isinstance(value,DATA): 
1032              self.__field_bytes=value 
1033          else: 
1034              self.__field_bytes=DATA(value,) 
1035   
1036 -    def __delfield_bytes(self): del self.__field_bytes 
1037   
1038      bytes=property(__getfield_bytes, __setfield_bytes, __delfield_bytes, None) 
1039   
1040 -    def iscontainer(self): 
1041          return True 
1042   
1043 -    def containerelements(self): 
1044          yield ('bytes', self.__field_bytes, None) 
1045   
1046   
1047   
1048   
1049 -class fspbslot(BaseProtogenClass): 
1050      __fields=['valid', 'pbbook_index', 'c0', 'timestamp', 'pad'] 
1051   
1052 -    def __init__(self, *args, **kwargs): 
1053          dict={} 
1054          # What was supplied to this function 
1055          dict.update(kwargs) 
1056          # Parent constructor 
1057          super(fspbslot,self).__init__(**dict) 
1058          if self.__class__ is fspbslot: 
1059              self._update(args,dict) 
1060   
1061   
1062 -    def getfields(self): 
1063          return self.__fields 
1064   
1065   
1066 -    def _update(self, args, kwargs): 
1067          super(fspbslot,self)._update(args,kwargs) 
1068          keys=kwargs.keys() 
1069          for key in keys: 
1070              if key in self.__fields: 
1071                  setattr(self, key, kwargs[key]) 
1072                  del kwargs[key] 
1073          # Were any unrecognized kwargs passed in? 
1074          if __debug__: 
1075              self._complainaboutunusedargs(fspbslot,kwargs) 
1076          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1077          # Make all P fields that haven't already been constructed 
1078   
1079   
1080 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1081          'Writes this packet to the supplied buffer' 
1082          self._bufferstartoffset=buf.getcurrentoffset() 
1083          try: self.__field_valid 
1084          except: 
1085              self.__field_valid=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
1086          self.__field_valid.writetobuffer(buf) 
1087          try: self.__field_pbbook_index 
1088          except: 
1089              self.__field_pbbook_index=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1090          self.__field_pbbook_index.writetobuffer(buf) 
1091          if self.valid: 
1092              try: self.__field_c0 
1093              except: 
1094                  self.__field_c0=UINT(**{'sizeinbytes': 2,  'default': 0x0101 }) 
1095              self.__field_c0.writetobuffer(buf) 
1096              try: self.__field_timestamp 
1097              except: 
1098                  self.__field_timestamp=DateTime(**{'sizeinbytes': 4,  'default': DateTime.now() }) 
1099              self.__field_timestamp.writetobuffer(buf) 
1100          else: 
1101              try: self.__field_pad 
1102              except: 
1103                  self.__field_pad=DATA(**{'sizeinbytes': 6,  'default': '\x00'*6 }) 
1104              self.__field_pad.writetobuffer(buf) 
1105          self._bufferendoffset=buf.getcurrentoffset() 
1106          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1107   
1108   
1109 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1110          'Reads this packet from the supplied buffer' 
1111          self._bufferstartoffset=buf.getcurrentoffset() 
1112          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1113          self.__field_valid=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
1114          self.__field_valid.readfrombuffer(buf) 
1115          self.__field_pbbook_index=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1116          self.__field_pbbook_index.readfrombuffer(buf) 
1117          if self.valid: 
1118              self.__field_c0=UINT(**{'sizeinbytes': 2,  'default': 0x0101 }) 
1119              self.__field_c0.readfrombuffer(buf) 
1120              self.__field_timestamp=DateTime(**{'sizeinbytes': 4,  'default': DateTime.now() }) 
1121              self.__field_timestamp.readfrombuffer(buf) 
1122          else: 
1123              self.__field_pad=DATA(**{'sizeinbytes': 6,  'default': '\x00'*6 }) 
1124              self.__field_pad.readfrombuffer(buf) 
1125          self._bufferendoffset=buf.getcurrentoffset() 
1126   
1127   
1128 -    def __getfield_valid(self): 
1129          try: self.__field_valid 
1130          except: 
1131              self.__field_valid=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
1132          return self.__field_valid.getvalue() 
1133   
1134 -    def __setfield_valid(self, value): 
1135          if isinstance(value,UINT): 
1136              self.__field_valid=value 
1137          else: 
1138              self.__field_valid=UINT(value,**{'sizeinbytes': 1,  'default': 0 }) 
1139   
1140 -    def __delfield_valid(self): del self.__field_valid 
1141   
1142      valid=property(__getfield_valid, __setfield_valid, __delfield_valid, "1=valid entry") 
1143   
1144 -    def __getfield_pbbook_index(self): 
1145          try: self.__field_pbbook_index 
1146          except: 
1147              self.__field_pbbook_index=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1148          return self.__field_pbbook_index.getvalue() 
1149   
1150 -    def __setfield_pbbook_index(self, value): 
1151          if isinstance(value,UINT): 
1152              self.__field_pbbook_index=value 
1153          else: 
1154              self.__field_pbbook_index=UINT(value,**{'sizeinbytes': 2,  'default': 0 }) 
1155   
1156 -    def __delfield_pbbook_index(self): del self.__field_pbbook_index 
1157   
1158      pbbook_index=property(__getfield_pbbook_index, __setfield_pbbook_index, __delfield_pbbook_index, "index into pbbook") 
1159   
1160 -    def __getfield_c0(self): 
1161          try: self.__field_c0 
1162          except: 
1163              self.__field_c0=UINT(**{'sizeinbytes': 2,  'default': 0x0101 }) 
1164          return self.__field_c0.getvalue() 
1165   
1166 -    def __setfield_c0(self, value): 
1167          if isinstance(value,UINT): 
1168              self.__field_c0=value 
1169          else: 
1170              self.__field_c0=UINT(value,**{'sizeinbytes': 2,  'default': 0x0101 }) 
1171   
1172 -    def __delfield_c0(self): del self.__field_c0 
1173   
1174      c0=property(__getfield_c0, __setfield_c0, __delfield_c0, None) 
1175   
1176 -    def __getfield_timestamp(self): 
1177          try: self.__field_timestamp 
1178          except: 
1179              self.__field_timestamp=DateTime(**{'sizeinbytes': 4,  'default': DateTime.now() }) 
1180          return self.__field_timestamp.getvalue() 
1181   
1182 -    def __setfield_timestamp(self, value): 
1183          if isinstance(value,DateTime): 
1184              self.__field_timestamp=value 
1185          else: 
1186              self.__field_timestamp=DateTime(value,**{'sizeinbytes': 4,  'default': DateTime.now() }) 
1187   
1188 -    def __delfield_timestamp(self): del self.__field_timestamp 
1189   
1190      timestamp=property(__getfield_timestamp, __setfield_timestamp, __delfield_timestamp, "Last modified date/time") 
1191   
1192 -    def __getfield_pad(self): 
1193          try: self.__field_pad 
1194          except: 
1195              self.__field_pad=DATA(**{'sizeinbytes': 6,  'default': '\x00'*6 }) 
1196          return self.__field_pad.getvalue() 
1197   
1198 -    def __setfield_pad(self, value): 
1199          if isinstance(value,DATA): 
1200              self.__field_pad=value 
1201          else: 
1202              self.__field_pad=DATA(value,**{'sizeinbytes': 6,  'default': '\x00'*6 }) 
1203   
1204 -    def __delfield_pad(self): del self.__field_pad 
1205   
1206      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
1207   
1208 -    def iscontainer(self): 
1209          return True 
1210   
1211 -    def containerelements(self): 
1212          yield ('valid', self.__field_valid, "1=valid entry") 
1213          yield ('pbbook_index', self.__field_pbbook_index, "index into pbbook") 
1214          if self.valid: 
1215              yield ('c0', self.__field_c0, None) 
1216              yield ('timestamp', self.__field_timestamp, "Last modified date/time") 
1217          else: 
1218              yield ('pad', self.__field_pad, None) 
1219   
1220   
1221   
1222   
1223 -class fspbslots(BaseProtogenClass): 
1224      __fields=['slot'] 
1225   
1226 -    def __init__(self, *args, **kwargs): 
1227          dict={} 
1228          # What was supplied to this function 
1229          dict.update(kwargs) 
1230          # Parent constructor 
1231          super(fspbslots,self).__init__(**dict) 
1232          if self.__class__ is fspbslots: 
1233              self._update(args,dict) 
1234   
1235   
1236 -    def getfields(self): 
1237          return self.__fields 
1238   
1239   
1240 -    def _update(self, args, kwargs): 
1241          super(fspbslots,self)._update(args,kwargs) 
1242          keys=kwargs.keys() 
1243          for key in keys: 
1244              if key in self.__fields: 
1245                  setattr(self, key, kwargs[key]) 
1246                  del kwargs[key] 
1247          # Were any unrecognized kwargs passed in? 
1248          if __debug__: 
1249              self._complainaboutunusedargs(fspbslots,kwargs) 
1250          if len(args): 
1251              dict2={ 'length': max_pb_slots, 'elementclass': fspbslot } 
1252              dict2.update(kwargs) 
1253              kwargs=dict2 
1254              self.__field_slot=LIST(*args,**dict2) 
1255          # Make all P fields that haven't already been constructed 
1256   
1257   
1258 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1259          'Writes this packet to the supplied buffer' 
1260          self._bufferstartoffset=buf.getcurrentoffset() 
1261          try: self.__field_slot 
1262          except: 
1263              self.__field_slot=LIST(**{ 'length': max_pb_slots, 'elementclass': fspbslot }) 
1264          self.__field_slot.writetobuffer(buf) 
1265          self._bufferendoffset=buf.getcurrentoffset() 
1266          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1267   
1268   
1269 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1270          'Reads this packet from the supplied buffer' 
1271          self._bufferstartoffset=buf.getcurrentoffset() 
1272          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1273          self.__field_slot=LIST(**{ 'length': max_pb_slots, 'elementclass': fspbslot }) 
1274          self.__field_slot.readfrombuffer(buf) 
1275          self._bufferendoffset=buf.getcurrentoffset() 
1276   
1277   
1278 -    def __getfield_slot(self): 
1279          try: self.__field_slot 
1280          except: 
1281              self.__field_slot=LIST(**{ 'length': max_pb_slots, 'elementclass': fspbslot }) 
1282          return self.__field_slot.getvalue() 
1283   
1284 -    def __setfield_slot(self, value): 
1285          if isinstance(value,LIST): 
1286              self.__field_slot=value 
1287          else: 
1288              self.__field_slot=LIST(value,**{ 'length': max_pb_slots, 'elementclass': fspbslot }) 
1289   
1290 -    def __delfield_slot(self): del self.__field_slot 
1291   
1292      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
1293   
1294 -    def iscontainer(self): 
1295          return True 
1296   
1297 -    def containerelements(self): 
1298          yield ('slot', self.__field_slot, None) 
1299   
1300   
1301   
1302   
1303 -class fspbentry(BaseProtogenClass): 
1304      __fields=['valid', 'c1', 'c1', 'main_num_index', 'mobile_num_index', 'home_num_index', 'office_num_index', 'pager_num_index', 'fax_num_index', 'unused_index', 'email_index', 'url_index', 'name', 'group_num', 'nick', 'memo', 'pad'] 
1305   
1306 -    def __init__(self, *args, **kwargs): 
1307          dict={} 
1308          # What was supplied to this function 
1309          dict.update(kwargs) 
1310          # Parent constructor 
1311          super(fspbentry,self).__init__(**dict) 
1312          if self.__class__ is fspbentry: 
1313              self._update(args,dict) 
1314   
1315   
1316 -    def getfields(self): 
1317          return self.__fields 
1318   
1319   
1320 -    def _update(self, args, kwargs): 
1321          super(fspbentry,self)._update(args,kwargs) 
1322          keys=kwargs.keys() 
1323          for key in keys: 
1324              if key in self.__fields: 
1325                  setattr(self, key, kwargs[key]) 
1326                  del kwargs[key] 
1327          # Were any unrecognized kwargs passed in? 
1328          if __debug__: 
1329              self._complainaboutunusedargs(fspbentry,kwargs) 
1330          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1331          # Make all P fields that haven't already been constructed 
1332   
1333   
1334 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1335          'Writes this packet to the supplied buffer' 
1336          self._bufferstartoffset=buf.getcurrentoffset() 
1337          try: self.__field_valid 
1338          except: 
1339              self.__field_valid=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
1340          self.__field_valid.writetobuffer(buf) 
1341          if self.valid: 
1342              try: self.__field_c1 
1343              except: 
1344                  self.__field_c1=UINT(**{'sizeinbytes': 2,  'default': 0x01BF }) 
1345              self.__field_c1.writetobuffer(buf) 
1346          else: 
1347              try: self.__field_c1 
1348              except: 
1349                  self.__field_c1=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1350              self.__field_c1.writetobuffer(buf) 
1351          try: self.__field_main_num_index 
1352          except: 
1353              self.__field_main_num_index=UINT(**{'sizeinbytes': 2,  'default': self.mobile_num_index }) 
1354          self.__field_main_num_index.writetobuffer(buf) 
1355          try: self.__field_mobile_num_index 
1356          except: 
1357              self.__field_mobile_num_index=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1358          self.__field_mobile_num_index.writetobuffer(buf) 
1359          try: self.__field_home_num_index 
1360          except: 
1361              self.__field_home_num_index=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1362          self.__field_home_num_index.writetobuffer(buf) 
1363          try: self.__field_office_num_index 
1364          except: 
1365              self.__field_office_num_index=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1366          self.__field_office_num_index.writetobuffer(buf) 
1367          try: self.__field_pager_num_index 
1368          except: 
1369              self.__field_pager_num_index=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1370          self.__field_pager_num_index.writetobuffer(buf) 
1371          try: self.__field_fax_num_index 
1372          except: 
1373              self.__field_fax_num_index=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1374          self.__field_fax_num_index.writetobuffer(buf) 
1375          try: self.__field_unused_index 
1376          except: 
1377              self.__field_unused_index=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1378          self.__field_unused_index.writetobuffer(buf) 
1379          try: self.__field_email_index 
1380          except: 
1381              self.__field_email_index=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1382          self.__field_email_index.writetobuffer(buf) 
1383          try: self.__field_url_index 
1384          except: 
1385              self.__field_url_index=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1386          self.__field_url_index.writetobuffer(buf) 
1387          try: self.__field_name 
1388          except: 
1389              self.__field_name=USTRING(**{'sizeinbytes': 31,  'pascal': True,                 'terminator': None,                 'default': '' }) 
1390          self.__field_name.writetobuffer(buf) 
1391          try: self.__field_group_num 
1392          except: 
1393              self.__field_group_num=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
1394          self.__field_group_num.writetobuffer(buf) 
1395          try: self.__field_nick 
1396          except: 
1397              self.__field_nick=USTRING(**{'sizeinbytes': 22,  'pascal': True,                 'terminator': None,                 'default': '' }) 
1398          self.__field_nick.writetobuffer(buf) 
1399          try: self.__field_memo 
1400          except: 
1401              self.__field_memo=USTRING(**{'sizeinbytes': 73,  'pascal': True,                 'terminator': None,                 'default': '' }) 
1402          self.__field_memo.writetobuffer(buf) 
1403          try: self.__field_pad 
1404          except: 
1405              self.__field_pad=DATA(**{'sizeinbytes': 13,  'default': '\x00'*13 }) 
1406          self.__field_pad.writetobuffer(buf) 
1407          self._bufferendoffset=buf.getcurrentoffset() 
1408          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1409   
1410   
1411 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1412          'Reads this packet from the supplied buffer' 
1413          self._bufferstartoffset=buf.getcurrentoffset() 
1414          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1415          self.__field_valid=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
1416          self.__field_valid.readfrombuffer(buf) 
1417          if self.valid: 
1418              self.__field_c1=UINT(**{'sizeinbytes': 2,  'default': 0x01BF }) 
1419              self.__field_c1.readfrombuffer(buf) 
1420          else: 
1421              self.__field_c1=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1422              self.__field_c1.readfrombuffer(buf) 
1423          self.__field_main_num_index=UINT(**{'sizeinbytes': 2,  'default': self.mobile_num_index }) 
1424          self.__field_main_num_index.readfrombuffer(buf) 
1425          self.__field_mobile_num_index=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1426          self.__field_mobile_num_index.readfrombuffer(buf) 
1427          self.__field_home_num_index=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1428          self.__field_home_num_index.readfrombuffer(buf) 
1429          self.__field_office_num_index=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1430          self.__field_office_num_index.readfrombuffer(buf) 
1431          self.__field_pager_num_index=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1432          self.__field_pager_num_index.readfrombuffer(buf) 
1433          self.__field_fax_num_index=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1434          self.__field_fax_num_index.readfrombuffer(buf) 
1435          self.__field_unused_index=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1436          self.__field_unused_index.readfrombuffer(buf) 
1437          self.__field_email_index=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1438          self.__field_email_index.readfrombuffer(buf) 
1439          self.__field_url_index=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1440          self.__field_url_index.readfrombuffer(buf) 
1441          self.__field_name=USTRING(**{'sizeinbytes': 31,  'pascal': True,                 'terminator': None,                 'default': '' }) 
1442          self.__field_name.readfrombuffer(buf) 
1443          self.__field_group_num=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
1444          self.__field_group_num.readfrombuffer(buf) 
1445          self.__field_nick=USTRING(**{'sizeinbytes': 22,  'pascal': True,                 'terminator': None,                 'default': '' }) 
1446          self.__field_nick.readfrombuffer(buf) 
1447          self.__field_memo=USTRING(**{'sizeinbytes': 73,  'pascal': True,                 'terminator': None,                 'default': '' }) 
1448          self.__field_memo.readfrombuffer(buf) 
1449          self.__field_pad=DATA(**{'sizeinbytes': 13,  'default': '\x00'*13 }) 
1450          self.__field_pad.readfrombuffer(buf) 
1451          self._bufferendoffset=buf.getcurrentoffset() 
1452   
1453   
1454 -    def __getfield_valid(self): 
1455          try: self.__field_valid 
1456          except: 
1457              self.__field_valid=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
1458          return self.__field_valid.getvalue() 
1459   
1460 -    def __setfield_valid(self, value): 
1461          if isinstance(value,UINT): 
1462              self.__field_valid=value 
1463          else: 
1464              self.__field_valid=UINT(value,**{'sizeinbytes': 1,  'default': 0 }) 
1465   
1466 -    def __delfield_valid(self): del self.__field_valid 
1467   
1468      valid=property(__getfield_valid, __setfield_valid, __delfield_valid, "1=valid entry") 
1469   
1470 -    def __getfield_c1(self): 
1471          try: self.__field_c1 
1472          except: 
1473              self.__field_c1=UINT(**{'sizeinbytes': 2,  'default': 0x01BF }) 
1474          return self.__field_c1.getvalue() 
1475   
1476 -    def __setfield_c1(self, value): 
1477          if isinstance(value,UINT): 
1478              self.__field_c1=value 
1479          else: 
1480              self.__field_c1=UINT(value,**{'sizeinbytes': 2,  'default': 0x01BF }) 
1481   
1482 -    def __delfield_c1(self): del self.__field_c1 
1483   
1484      c1=property(__getfield_c1, __setfield_c1, __delfield_c1, None) 
1485   
1486 -    def __getfield_c1(self): 
1487          try: self.__field_c1 
1488          except: 
1489              self.__field_c1=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1490          return self.__field_c1.getvalue() 
1491   
1492 -    def __setfield_c1(self, value): 
1493          if isinstance(value,UINT): 
1494              self.__field_c1=value 
1495          else: 
1496              self.__field_c1=UINT(value,**{'sizeinbytes': 2,  'default': 0 }) 
1497   
1498 -    def __delfield_c1(self): del self.__field_c1 
1499   
1500      c1=property(__getfield_c1, __setfield_c1, __delfield_c1, None) 
1501   
1502 -    def __getfield_main_num_index(self): 
1503          try: self.__field_main_num_index 
1504          except: 
1505              self.__field_main_num_index=UINT(**{'sizeinbytes': 2,  'default': self.mobile_num_index }) 
1506          return self.__field_main_num_index.getvalue() 
1507   
1508 -    def __setfield_main_num_index(self, value): 
1509          if isinstance(value,UINT): 
1510              self.__field_main_num_index=value 
1511          else: 
1512              self.__field_main_num_index=UINT(value,**{'sizeinbytes': 2,  'default': self.mobile_num_index }) 
1513   
1514 -    def __delfield_main_num_index(self): del self.__field_main_num_index 
1515   
1516      main_num_index=property(__getfield_main_num_index, __setfield_main_num_index, __delfield_main_num_index, None) 
1517   
1518 -    def __getfield_mobile_num_index(self): 
1519          try: self.__field_mobile_num_index 
1520          except: 
1521              self.__field_mobile_num_index=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1522          return self.__field_mobile_num_index.getvalue() 
1523   
1524 -    def __setfield_mobile_num_index(self, value): 
1525          if isinstance(value,UINT): 
1526              self.__field_mobile_num_index=value 
1527          else: 
1528              self.__field_mobile_num_index=UINT(value,**{'sizeinbytes': 2,  'default': 0 }) 
1529   
1530 -    def __delfield_mobile_num_index(self): del self.__field_mobile_num_index 
1531   
1532      mobile_num_index=property(__getfield_mobile_num_index, __setfield_mobile_num_index, __delfield_mobile_num_index, None) 
1533   
1534 -    def __getfield_home_num_index(self): 
1535          try: self.__field_home_num_index 
1536          except: 
1537              self.__field_home_num_index=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1538          return self.__field_home_num_index.getvalue() 
1539   
1540 -    def __setfield_home_num_index(self, value): 
1541          if isinstance(value,UINT): 
1542              self.__field_home_num_index=value 
1543          else: 
1544              self.__field_home_num_index=UINT(value,**{'sizeinbytes': 2,  'default': 0 }) 
1545   
1546 -    def __delfield_home_num_index(self): del self.__field_home_num_index 
1547   
1548      home_num_index=property(__getfield_home_num_index, __setfield_home_num_index, __delfield_home_num_index, None) 
1549   
1550 -    def __getfield_office_num_index(self): 
1551          try: self.__field_office_num_index 
1552          except: 
1553              self.__field_office_num_index=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1554          return self.__field_office_num_index.getvalue() 
1555   
1556 -    def __setfield_office_num_index(self, value): 
1557          if isinstance(value,UINT): 
1558              self.__field_office_num_index=value 
1559          else: 
1560              self.__field_office_num_index=UINT(value,**{'sizeinbytes': 2,  'default': 0 }) 
1561   
1562 -    def __delfield_office_num_index(self): del self.__field_office_num_index 
1563   
1564      office_num_index=property(__getfield_office_num_index, __setfield_office_num_index, __delfield_office_num_index, None) 
1565   
1566 -    def __getfield_pager_num_index(self): 
1567          try: self.__field_pager_num_index 
1568          except: 
1569              self.__field_pager_num_index=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1570          return self.__field_pager_num_index.getvalue() 
1571   
1572 -    def __setfield_pager_num_index(self, value): 
1573          if isinstance(value,UINT): 
1574              self.__field_pager_num_index=value 
1575          else: 
1576              self.__field_pager_num_index=UINT(value,**{'sizeinbytes': 2,  'default': 0 }) 
1577   
1578 -    def __delfield_pager_num_index(self): del self.__field_pager_num_index 
1579   
1580      pager_num_index=property(__getfield_pager_num_index, __setfield_pager_num_index, __delfield_pager_num_index, None) 
1581   
1582 -    def __getfield_fax_num_index(self): 
1583          try: self.__field_fax_num_index 
1584          except: 
1585              self.__field_fax_num_index=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1586          return self.__field_fax_num_index.getvalue() 
1587   
1588 -    def __setfield_fax_num_index(self, value): 
1589          if isinstance(value,UINT): 
1590              self.__field_fax_num_index=value 
1591          else: 
1592              self.__field_fax_num_index=UINT(value,**{'sizeinbytes': 2,  'default': 0 }) 
1593   
1594 -    def __delfield_fax_num_index(self): del self.__field_fax_num_index 
1595   
1596      fax_num_index=property(__getfield_fax_num_index, __setfield_fax_num_index, __delfield_fax_num_index, None) 
1597   
1598 -    def __getfield_unused_index(self): 
1599          try: self.__field_unused_index 
1600          except: 
1601              self.__field_unused_index=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1602          return self.__field_unused_index.getvalue() 
1603   
1604 -    def __setfield_unused_index(self, value): 
1605          if isinstance(value,UINT): 
1606              self.__field_unused_index=value 
1607          else: 
1608              self.__field_unused_index=UINT(value,**{'sizeinbytes': 2,  'default': 0 }) 
1609   
1610 -    def __delfield_unused_index(self): del self.__field_unused_index 
1611   
1612      unused_index=property(__getfield_unused_index, __setfield_unused_index, __delfield_unused_index, None) 
1613   
1614 -    def __getfield_email_index(self): 
1615          try: self.__field_email_index 
1616          except: 
1617              self.__field_email_index=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1618          return self.__field_email_index.getvalue() 
1619   
1620 -    def __setfield_email_index(self, value): 
1621          if isinstance(value,UINT): 
1622              self.__field_email_index=value 
1623          else: 
1624              self.__field_email_index=UINT(value,**{'sizeinbytes': 2,  'default': 0 }) 
1625   
1626 -    def __delfield_email_index(self): del self.__field_email_index 
1627   
1628      email_index=property(__getfield_email_index, __setfield_email_index, __delfield_email_index, None) 
1629   
1630 -    def __getfield_url_index(self): 
1631          try: self.__field_url_index 
1632          except: 
1633              self.__field_url_index=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1634          return self.__field_url_index.getvalue() 
1635   
1636 -    def __setfield_url_index(self, value): 
1637          if isinstance(value,UINT): 
1638              self.__field_url_index=value 
1639          else: 
1640              self.__field_url_index=UINT(value,**{'sizeinbytes': 2,  'default': 0 }) 
1641   
1642 -    def __delfield_url_index(self): del self.__field_url_index 
1643   
1644      url_index=property(__getfield_url_index, __setfield_url_index, __delfield_url_index, None) 
1645   
1646 -    def __getfield_name(self): 
1647          try: self.__field_name 
1648          except: 
1649              self.__field_name=USTRING(**{'sizeinbytes': 31,  'pascal': True,                 'terminator': None,                 'default': '' }) 
1650          return self.__field_name.getvalue() 
1651   
1652 -    def __setfield_name(self, value): 
1653          if isinstance(value,USTRING): 
1654              self.__field_name=value 
1655          else: 
1656              self.__field_name=USTRING(value,**{'sizeinbytes': 31,  'pascal': True,                 'terminator': None,                 'default': '' }) 
1657   
1658 -    def __delfield_name(self): del self.__field_name 
1659   
1660      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
1661   
1662 -    def __getfield_group_num(self): 
1663          try: self.__field_group_num 
1664          except: 
1665              self.__field_group_num=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
1666          return self.__field_group_num.getvalue() 
1667   
1668 -    def __setfield_group_num(self, value): 
1669          if isinstance(value,UINT): 
1670              self.__field_group_num=value 
1671          else: 
1672              self.__field_group_num=UINT(value,**{'sizeinbytes': 1,  'default': 0 }) 
1673   
1674 -    def __delfield_group_num(self): del self.__field_group_num 
1675   
1676      group_num=property(__getfield_group_num, __setfield_group_num, __delfield_group_num, None) 
1677   
1678 -    def __getfield_nick(self): 
1679          try: self.__field_nick 
1680          except: 
1681              self.__field_nick=USTRING(**{'sizeinbytes': 22,  'pascal': True,                 'terminator': None,                 'default': '' }) 
1682          return self.__field_nick.getvalue() 
1683   
1684 -    def __setfield_nick(self, value): 
1685          if isinstance(value,USTRING): 
1686              self.__field_nick=value 
1687          else: 
1688              self.__field_nick=USTRING(value,**{'sizeinbytes': 22,  'pascal': True,                 'terminator': None,                 'default': '' }) 
1689   
1690 -    def __delfield_nick(self): del self.__field_nick 
1691   
1692      nick=property(__getfield_nick, __setfield_nick, __delfield_nick, None) 
1693   
1694 -    def __getfield_memo(self): 
1695          try: self.__field_memo 
1696          except: 
1697              self.__field_memo=USTRING(**{'sizeinbytes': 73,  'pascal': True,                 'terminator': None,                 'default': '' }) 
1698          return self.__field_memo.getvalue() 
1699   
1700 -    def __setfield_memo(self, value): 
1701          if isinstance(value,USTRING): 
1702              self.__field_memo=value 
1703          else: 
1704              self.__field_memo=USTRING(value,**{'sizeinbytes': 73,  'pascal': True,                 'terminator': None,                 'default': '' }) 
1705   
1706 -    def __delfield_memo(self): del self.__field_memo 
1707   
1708      memo=property(__getfield_memo, __setfield_memo, __delfield_memo, None) 
1709   
1710 -    def __getfield_pad(self): 
1711          try: self.__field_pad 
1712          except: 
1713              self.__field_pad=DATA(**{'sizeinbytes': 13,  'default': '\x00'*13 }) 
1714          return self.__field_pad.getvalue() 
1715   
1716 -    def __setfield_pad(self, value): 
1717          if isinstance(value,DATA): 
1718              self.__field_pad=value 
1719          else: 
1720              self.__field_pad=DATA(value,**{'sizeinbytes': 13,  'default': '\x00'*13 }) 
1721   
1722 -    def __delfield_pad(self): del self.__field_pad 
1723   
1724      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
1725   
1726 -    def iscontainer(self): 
1727          return True 
1728   
1729 -    def containerelements(self): 
1730          yield ('valid', self.__field_valid, "1=valid entry") 
1731          if self.valid: 
1732              yield ('c1', self.__field_c1, None) 
1733          else: 
1734              yield ('c1', self.__field_c1, None) 
1735          yield ('main_num_index', self.__field_main_num_index, None) 
1736          yield ('mobile_num_index', self.__field_mobile_num_index, None) 
1737          yield ('home_num_index', self.__field_home_num_index, None) 
1738          yield ('office_num_index', self.__field_office_num_index, None) 
1739          yield ('pager_num_index', self.__field_pager_num_index, None) 
1740          yield ('fax_num_index', self.__field_fax_num_index, None) 
1741          yield ('unused_index', self.__field_unused_index, None) 
1742          yield ('email_index', self.__field_email_index, None) 
1743          yield ('url_index', self.__field_url_index, None) 
1744          yield ('name', self.__field_name, None) 
1745          yield ('group_num', self.__field_group_num, None) 
1746          yield ('nick', self.__field_nick, None) 
1747          yield ('memo', self.__field_memo, None) 
1748          yield ('pad', self.__field_pad, None) 
1749   
1750   
1751   
1752   
1753 -class fspbbook(BaseProtogenClass): 
1754      __fields=['entry'] 
1755   
1756 -    def __init__(self, *args, **kwargs): 
1757          dict={} 
1758          # What was supplied to this function 
1759          dict.update(kwargs) 
1760          # Parent constructor 
1761          super(fspbbook,self).__init__(**dict) 
1762          if self.__class__ is fspbbook: 
1763              self._update(args,dict) 
1764   
1765   
1766 -    def getfields(self): 
1767          return self.__fields 
1768   
1769   
1770 -    def _update(self, args, kwargs): 
1771          super(fspbbook,self)._update(args,kwargs) 
1772          keys=kwargs.keys() 
1773          for key in keys: 
1774              if key in self.__fields: 
1775                  setattr(self, key, kwargs[key]) 
1776                  del kwargs[key] 
1777          # Were any unrecognized kwargs passed in? 
1778          if __debug__: 
1779              self._complainaboutunusedargs(fspbbook,kwargs) 
1780          if len(args): 
1781              dict2={ 'length': max_pb_entries,               'elementclass': fspbentry,               'createdefault': True } 
1782              dict2.update(kwargs) 
1783              kwargs=dict2 
1784              self.__field_entry=LIST(*args,**dict2) 
1785          # Make all P fields that haven't already been constructed 
1786   
1787   
1788 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1789          'Writes this packet to the supplied buffer' 
1790          self._bufferstartoffset=buf.getcurrentoffset() 
1791          try: self.__field_entry 
1792          except: 
1793              self.__field_entry=LIST(**{ 'length': max_pb_entries,               'elementclass': fspbentry,               'createdefault': True }) 
1794          self.__field_entry.writetobuffer(buf) 
1795          self._bufferendoffset=buf.getcurrentoffset() 
1796          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1797   
1798   
1799 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1800          'Reads this packet from the supplied buffer' 
1801          self._bufferstartoffset=buf.getcurrentoffset() 
1802          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1803          self.__field_entry=LIST(**{ 'length': max_pb_entries,               'elementclass': fspbentry,               'createdefault': True }) 
1804          self.__field_entry.readfrombuffer(buf) 
1805          self._bufferendoffset=buf.getcurrentoffset() 
1806   
1807   
1808 -    def __getfield_entry(self): 
1809          try: self.__field_entry 
1810          except: 
1811              self.__field_entry=LIST(**{ 'length': max_pb_entries,               'elementclass': fspbentry,               'createdefault': True }) 
1812          return self.__field_entry.getvalue() 
1813   
1814 -    def __setfield_entry(self, value): 
1815          if isinstance(value,LIST): 
1816              self.__field_entry=value 
1817          else: 
1818              self.__field_entry=LIST(value,**{ 'length': max_pb_entries,               'elementclass': fspbentry,               'createdefault': True }) 
1819   
1820 -    def __delfield_entry(self): del self.__field_entry 
1821   
1822      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
1823   
1824 -    def iscontainer(self): 
1825          return True 
1826   
1827 -    def containerelements(self): 
1828          yield ('entry', self.__field_entry, None) 
1829   
1830   
1831   
1832   
1833 -class fsnumber(BaseProtogenClass): 
1834      __fields=['valid', 'c0', 'name', 'number_type'] 
1835   
1836 -    def __init__(self, *args, **kwargs): 
1837          dict={} 
1838          # What was supplied to this function 
1839          dict.update(kwargs) 
1840          # Parent constructor 
1841          super(fsnumber,self).__init__(**dict) 
1842          if self.__class__ is fsnumber: 
1843              self._update(args,dict) 
1844   
1845   
1846 -    def getfields(self): 
1847          return self.__fields 
1848   
1849   
1850 -    def _update(self, args, kwargs): 
1851          super(fsnumber,self)._update(args,kwargs) 
1852          keys=kwargs.keys() 
1853          for key in keys: 
1854              if key in self.__fields: 
1855                  setattr(self, key, kwargs[key]) 
1856                  del kwargs[key] 
1857          # Were any unrecognized kwargs passed in? 
1858          if __debug__: 
1859              self._complainaboutunusedargs(fsnumber,kwargs) 
1860          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1861          # Make all P fields that haven't already been constructed 
1862   
1863   
1864 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1865          'Writes this packet to the supplied buffer' 
1866          self._bufferstartoffset=buf.getcurrentoffset() 
1867          try: self.__field_valid 
1868          except: 
1869              self.__field_valid=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1870          self.__field_valid.writetobuffer(buf) 
1871          try: self.__field_c0 
1872          except: 
1873              self.__field_c0=UINT(**{'sizeinbytes': 4,  'default': 0 }) 
1874          self.__field_c0.writetobuffer(buf) 
1875          try: self.__field_name 
1876          except: 
1877              self.__field_name=USTRING(**{'sizeinbytes': 74,  'pascal': True,                  'terminator': None,                  'default': '' }) 
1878          self.__field_name.writetobuffer(buf) 
1879          try: self.__field_number_type 
1880          except: 
1881              self.__field_number_type=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
1882          self.__field_number_type.writetobuffer(buf) 
1883          self._bufferendoffset=buf.getcurrentoffset() 
1884          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1885   
1886   
1887 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1888          'Reads this packet from the supplied buffer' 
1889          self._bufferstartoffset=buf.getcurrentoffset() 
1890          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1891          self.__field_valid=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1892          self.__field_valid.readfrombuffer(buf) 
1893          self.__field_c0=UINT(**{'sizeinbytes': 4,  'default': 0 }) 
1894          self.__field_c0.readfrombuffer(buf) 
1895          self.__field_name=USTRING(**{'sizeinbytes': 74,  'pascal': True,                  'terminator': None,                  'default': '' }) 
1896          self.__field_name.readfrombuffer(buf) 
1897          self.__field_number_type=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
1898          self.__field_number_type.readfrombuffer(buf) 
1899          self._bufferendoffset=buf.getcurrentoffset() 
1900   
1901   
1902 -    def __getfield_valid(self): 
1903          try: self.__field_valid 
1904          except: 
1905              self.__field_valid=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1906          return self.__field_valid.getvalue() 
1907   
1908 -    def __setfield_valid(self, value): 
1909          if isinstance(value,UINT): 
1910              self.__field_valid=value 
1911          else: 
1912              self.__field_valid=UINT(value,**{'sizeinbytes': 2,  'default': 0 }) 
1913   
1914 -    def __delfield_valid(self): del self.__field_valid 
1915   
1916      valid=property(__getfield_valid, __setfield_valid, __delfield_valid, "1=valid entry") 
1917   
1918 -    def __getfield_c0(self): 
1919          try: self.__field_c0 
1920          except: 
1921              self.__field_c0=UINT(**{'sizeinbytes': 4,  'default': 0 }) 
1922          return self.__field_c0.getvalue() 
1923   
1924 -    def __setfield_c0(self, value): 
1925          if isinstance(value,UINT): 
1926              self.__field_c0=value 
1927          else: 
1928              self.__field_c0=UINT(value,**{'sizeinbytes': 4,  'default': 0 }) 
1929   
1930 -    def __delfield_c0(self): del self.__field_c0 
1931   
1932      c0=property(__getfield_c0, __setfield_c0, __delfield_c0, None) 
1933   
1934 -    def __getfield_name(self): 
1935          try: self.__field_name 
1936          except: 
1937              self.__field_name=USTRING(**{'sizeinbytes': 74,  'pascal': True,                  'terminator': None,                  'default': '' }) 
1938          return self.__field_name.getvalue() 
1939   
1940 -    def __setfield_name(self, value): 
1941          if isinstance(value,USTRING): 
1942              self.__field_name=value 
1943          else: 
1944              self.__field_name=USTRING(value,**{'sizeinbytes': 74,  'pascal': True,                  'terminator': None,                  'default': '' }) 
1945   
1946 -    def __delfield_name(self): del self.__field_name 
1947   
1948      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
1949   
1950 -    def __getfield_number_type(self): 
1951          try: self.__field_number_type 
1952          except: 
1953              self.__field_number_type=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
1954          return self.__field_number_type.getvalue() 
1955   
1956 -    def __setfield_number_type(self, value): 
1957          if isinstance(value,UINT): 
1958              self.__field_number_type=value 
1959          else: 
1960              self.__field_number_type=UINT(value,**{'sizeinbytes': 1,  'default': 0 }) 
1961   
1962 -    def __delfield_number_type(self): del self.__field_number_type 
1963   
1964      number_type=property(__getfield_number_type, __setfield_number_type, __delfield_number_type, None) 
1965   
1966 -    def iscontainer(self): 
1967          return True 
1968   
1969 -    def containerelements(self): 
1970          yield ('valid', self.__field_valid, "1=valid entry") 
1971          yield ('c0', self.__field_c0, None) 
1972          yield ('name', self.__field_name, None) 
1973          yield ('number_type', self.__field_number_type, None) 
1974   
1975   
1976   
1977   
1978 -class fsnumbers(BaseProtogenClass): 
1979      __fields=['entry'] 
1980   
1981 -    def __init__(self, *args, **kwargs): 
1982          dict={} 
1983          # What was supplied to this function 
1984          dict.update(kwargs) 
1985          # Parent constructor 
1986          super(fsnumbers,self).__init__(**dict) 
1987          if self.__class__ is fsnumbers: 
1988              self._update(args,dict) 
1989   
1990   
1991 -    def getfields(self): 
1992          return self.__fields 
1993   
1994   
1995 -    def _update(self, args, kwargs): 
1996          super(fsnumbers,self)._update(args,kwargs) 
1997          keys=kwargs.keys() 
1998          for key in keys: 
1999              if key in self.__fields: 
2000                  setattr(self, key, kwargs[key]) 
2001                  del kwargs[key] 
2002          # Were any unrecognized kwargs passed in? 
2003          if __debug__: 
2004              self._complainaboutunusedargs(fsnumbers,kwargs) 
2005          if len(args): 
2006              dict2={ 'length': max_number_entries,              'elementclass': fsnumber,              'createdefault': True } 
2007              dict2.update(kwargs) 
2008              kwargs=dict2 
2009              self.__field_entry=LIST(*args,**dict2) 
2010          # Make all P fields that haven't already been constructed 
2011   
2012   
2013 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2014          'Writes this packet to the supplied buffer' 
2015          self._bufferstartoffset=buf.getcurrentoffset() 
2016          try: self.__field_entry 
2017          except: 
2018              self.__field_entry=LIST(**{ 'length': max_number_entries,              'elementclass': fsnumber,              'createdefault': True }) 
2019          self.__field_entry.writetobuffer(buf) 
2020          self._bufferendoffset=buf.getcurrentoffset() 
2021          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2022   
2023   
2024 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2025          'Reads this packet from the supplied buffer' 
2026          self._bufferstartoffset=buf.getcurrentoffset() 
2027          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2028          self.__field_entry=LIST(**{ 'length': max_number_entries,              'elementclass': fsnumber,              'createdefault': True }) 
2029          self.__field_entry.readfrombuffer(buf) 
2030          self._bufferendoffset=buf.getcurrentoffset() 
2031   
2032   
2033 -    def __getfield_entry(self): 
2034          try: self.__field_entry 
2035          except: 
2036              self.__field_entry=LIST(**{ 'length': max_number_entries,              'elementclass': fsnumber,              'createdefault': True }) 
2037          return self.__field_entry.getvalue() 
2038   
2039 -    def __setfield_entry(self, value): 
2040          if isinstance(value,LIST): 
2041              self.__field_entry=value 
2042          else: 
2043              self.__field_entry=LIST(value,**{ 'length': max_number_entries,              'elementclass': fsnumber,              'createdefault': True }) 
2044   
2045 -    def __delfield_entry(self): del self.__field_entry 
2046   
2047      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
2048   
2049 -    def iscontainer(self): 
2050          return True 
2051   
2052 -    def containerelements(self): 
2053          yield ('entry', self.__field_entry, None) 
2054   
2055   
2056   
2057   
2058 -class amsregistry(BaseProtogenClass): 
2059      __fields=['dunno0', 'info', 'dunno1', 'strings', 'dunno2', 'nfiles', 'dunno3'] 
2060   
2061 -    def __init__(self, *args, **kwargs): 
2062          dict={} 
2063          # What was supplied to this function 
2064          dict.update(kwargs) 
2065          # Parent constructor 
2066          super(amsregistry,self).__init__(**dict) 
2067          if self.__class__ is amsregistry: 
2068              self._update(args,dict) 
2069   
2070   
2071 -    def getfields(self): 
2072          return self.__fields 
2073   
2074   
2075 -    def _update(self, args, kwargs): 
2076          super(amsregistry,self)._update(args,kwargs) 
2077          keys=kwargs.keys() 
2078          for key in keys: 
2079              if key in self.__fields: 
2080                  setattr(self, key, kwargs[key]) 
2081                  del kwargs[key] 
2082          # Were any unrecognized kwargs passed in? 
2083          if __debug__: 
2084              self._complainaboutunusedargs(amsregistry,kwargs) 
2085          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2086          # Make all P fields that haven't already been constructed 
2087   
2088   
2089 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2090          'Writes this packet to the supplied buffer' 
2091          self._bufferstartoffset=buf.getcurrentoffset() 
2092          self.__field_dunno0.writetobuffer(buf) 
2093          self.__field_info.writetobuffer(buf) 
2094          self.__field_dunno1.writetobuffer(buf) 
2095          self.__field_strings.writetobuffer(buf) 
2096          self.__field_dunno2.writetobuffer(buf) 
2097          self.__field_nfiles.writetobuffer(buf) 
2098          self.__field_dunno3.writetobuffer(buf) 
2099          self._bufferendoffset=buf.getcurrentoffset() 
2100          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2101   
2102   
2103 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2104          'Reads this packet from the supplied buffer' 
2105          self._bufferstartoffset=buf.getcurrentoffset() 
2106          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2107          self.__field_dunno0=DATA(**{'sizeinbytes': 900}) 
2108          self.__field_dunno0.readfrombuffer(buf) 
2109          self.__field_info=LIST(**{'elementclass': _gen_p_samsungsphm300_197, 'length': 320}) 
2110          self.__field_info.readfrombuffer(buf) 
2111          self.__field_dunno1=DATA(**{'sizeinbytes': 2000}) 
2112          self.__field_dunno1.readfrombuffer(buf) 
2113          self.__field_strings=DATA(**{'sizeinbytes': 23000}) 
2114          self.__field_strings.readfrombuffer(buf) 
2115          self.__field_dunno2=UINT(**{'sizeinbytes': 4}) 
2116          self.__field_dunno2.readfrombuffer(buf) 
2117          self.__field_nfiles=UINT(**{'sizeinbytes': 2}) 
2118          self.__field_nfiles.readfrombuffer(buf) 
2119          self.__field_dunno3=DATA() 
2120          self.__field_dunno3.readfrombuffer(buf) 
2121          self._bufferendoffset=buf.getcurrentoffset() 
2122   
2123   
2124 -    def __getfield_dunno0(self): 
2125          return self.__field_dunno0.getvalue() 
2126   
2127 -    def __setfield_dunno0(self, value): 
2128          if isinstance(value,DATA): 
2129              self.__field_dunno0=value 
2130          else: 
2131              self.__field_dunno0=DATA(value,**{'sizeinbytes': 900}) 
2132   
2133 -    def __delfield_dunno0(self): del self.__field_dunno0 
2134   
2135      dunno0=property(__getfield_dunno0, __setfield_dunno0, __delfield_dunno0, None) 
2136   
2137 -    def __getfield_info(self): 
2138          return self.__field_info.getvalue() 
2139   
2140 -    def __setfield_info(self, value): 
2141          if isinstance(value,LIST): 
2142              self.__field_info=value 
2143          else: 
2144              self.__field_info=LIST(value,**{'elementclass': _gen_p_samsungsphm300_197, 'length': 320}) 
2145   
2146 -    def __delfield_info(self): del self.__field_info 
2147   
2148      info=property(__getfield_info, __setfield_info, __delfield_info, None) 
2149   
2150 -    def __getfield_dunno1(self): 
2151          return self.__field_dunno1.getvalue() 
2152   
2153 -    def __setfield_dunno1(self, value): 
2154          if isinstance(value,DATA): 
2155              self.__field_dunno1=value 
2156          else: 
2157              self.__field_dunno1=DATA(value,**{'sizeinbytes': 2000}) 
2158   
2159 -    def __delfield_dunno1(self): del self.__field_dunno1 
2160   
2161      dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None) 
2162   
2163 -    def __getfield_strings(self): 
2164          return self.__field_strings.getvalue() 
2165   
2166 -    def __setfield_strings(self, value): 
2167          if isinstance(value,DATA): 
2168              self.__field_strings=value 
2169          else: 
2170              self.__field_strings=DATA(value,**{'sizeinbytes': 23000}) 
2171   
2172 -    def __delfield_strings(self): del self.__field_strings 
2173   
2174      strings=property(__getfield_strings, __setfield_strings, __delfield_strings, None) 
2175   
2176 -    def __getfield_dunno2(self): 
2177          return self.__field_dunno2.getvalue() 
2178   
2179 -    def __setfield_dunno2(self, value): 
2180          if isinstance(value,UINT): 
2181              self.__field_dunno2=value 
2182          else: 
2183              self.__field_dunno2=UINT(value,**{'sizeinbytes': 4}) 
2184   
2185 -    def __delfield_dunno2(self): del self.__field_dunno2 
2186   
2187      dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None) 
2188   
2189 -    def __getfield_nfiles(self): 
2190          return self.__field_nfiles.getvalue() 
2191   
2192 -    def __setfield_nfiles(self, value): 
2193          if isinstance(value,UINT): 
2194              self.__field_nfiles=value 
2195          else: 
2196              self.__field_nfiles=UINT(value,**{'sizeinbytes': 2}) 
2197   
2198 -    def __delfield_nfiles(self): del self.__field_nfiles 
2199   
2200      nfiles=property(__getfield_nfiles, __setfield_nfiles, __delfield_nfiles, None) 
2201   
2202 -    def __getfield_dunno3(self): 
2203          return self.__field_dunno3.getvalue() 
2204   
2205 -    def __setfield_dunno3(self, value): 
2206          if isinstance(value,DATA): 
2207              self.__field_dunno3=value 
2208          else: 
2209              self.__field_dunno3=DATA(value,) 
2210   
2211 -    def __delfield_dunno3(self): del self.__field_dunno3 
2212   
2213      dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None) 
2214   
2215 -    def iscontainer(self): 
2216          return True 
2217   
2218 -    def containerelements(self): 
2219          yield ('dunno0', self.__field_dunno0, None) 
2220          yield ('info', self.__field_info, None) 
2221          yield ('dunno1', self.__field_dunno1, None) 
2222          yield ('strings', self.__field_strings, None) 
2223          yield ('dunno2', self.__field_dunno2, None) 
2224          yield ('nfiles', self.__field_nfiles, None) 
2225          yield ('dunno3', self.__field_dunno3, None) 
2226   
2227 -    def getstring(self, ptr): 
2228          # Return the 0-terminated string starting index ptr from field strings 
2229          try: 
2230              return self.strings[ptr:self.strings.index('\x00', ptr)] 
2231          except ValueError: 
2232              return '' 
2233 -    def dir(self, idx): 
2234          return self.getstring(self.info[idx].dir_ptr) 
2235 -    def name(self, idx): 
2236          return self.getstring(self.info[idx].name_ptr) 
2237 -    def mimetype(self, idx): 
2238          return self.getstring(self.info[idx].mimetype_ptr) 
2239 -    def version(self, idx): 
2240          return self.getstring(self.info[idx].version_ptr) 
2241 -    def vendor(self, idx): 
2242          return self.getstring(self.info[idx].vendor_ptr) 
2243 -    def filename(self, idx): 
2244          # return the file name of this item 
2245          global exts 
2246          return self.name(idx)+exts.get(self.mimetype(idx), '') 
2247 -    def filepath(self, idx): 
2248          # return the full pathname of this item 
2249          return 'ams/'+self.dir(idx) 
2250 -    def origin(self, idx): 
2251          # return the origin based on the file type 
2252          global origins 
2253          return origins.get(self.info[idx].filetype, None) 
2254   
2255   
2256   
2257   
2258 -class _gen_p_samsungsphm300_197(BaseProtogenClass): 
2259      'Anonymous inner class' 
2260      __fields=['dir_ptr', 'num2', 'name_ptr', 'version_ptr', 'vendor_ptr', 'downloaddomain_ptr', 'num7', 'filetype', 'num8', 'mimetype_ptr', 'num12'] 
2261   
2262 -    def __init__(self, *args, **kwargs): 
2263          dict={} 
2264          # What was supplied to this function 
2265          dict.update(kwargs) 
2266          # Parent constructor 
2267          super(_gen_p_samsungsphm300_197,self).__init__(**dict) 
2268          if self.__class__ is _gen_p_samsungsphm300_197: 
2269              self._update(args,dict) 
2270   
2271   
2272 -    def getfields(self): 
2273          return self.__fields 
2274   
2275   
2276 -    def _update(self, args, kwargs): 
2277          super(_gen_p_samsungsphm300_197,self)._update(args,kwargs) 
2278          keys=kwargs.keys() 
2279          for key in keys: 
2280              if key in self.__fields: 
2281                  setattr(self, key, kwargs[key]) 
2282                  del kwargs[key] 
2283          # Were any unrecognized kwargs passed in? 
2284          if __debug__: 
2285              self._complainaboutunusedargs(_gen_p_samsungsphm300_197,kwargs) 
2286          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2287          # Make all P fields that haven't already been constructed 
2288   
2289   
2290 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2291          'Writes this packet to the supplied buffer' 
2292          self._bufferstartoffset=buf.getcurrentoffset() 
2293          self.__field_dir_ptr.writetobuffer(buf) 
2294          self.__field_num2.writetobuffer(buf) 
2295          self.__field_name_ptr.writetobuffer(buf) 
2296          self.__field_version_ptr.writetobuffer(buf) 
2297          self.__field_vendor_ptr.writetobuffer(buf) 
2298          self.__field_downloaddomain_ptr.writetobuffer(buf) 
2299          self.__field_num7.writetobuffer(buf) 
2300          self.__field_filetype.writetobuffer(buf) 
2301          self.__field_num8.writetobuffer(buf) 
2302          self.__field_mimetype_ptr.writetobuffer(buf) 
2303          self.__field_num12.writetobuffer(buf) 
2304          self._bufferendoffset=buf.getcurrentoffset() 
2305          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2306   
2307   
2308 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2309          'Reads this packet from the supplied buffer' 
2310          self._bufferstartoffset=buf.getcurrentoffset() 
2311          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2312          self.__field_dir_ptr=UINT(**{'sizeinbytes': 2}) 
2313          self.__field_dir_ptr.readfrombuffer(buf) 
2314          self.__field_num2=UINT(**{'sizeinbytes': 2}) 
2315          self.__field_num2.readfrombuffer(buf) 
2316          self.__field_name_ptr=UINT(**{'sizeinbytes': 2}) 
2317          self.__field_name_ptr.readfrombuffer(buf) 
2318          self.__field_version_ptr=UINT(**{'sizeinbytes': 2}) 
2319          self.__field_version_ptr.readfrombuffer(buf) 
2320          self.__field_vendor_ptr=UINT(**{'sizeinbytes': 2}) 
2321          self.__field_vendor_ptr.readfrombuffer(buf) 
2322          self.__field_downloaddomain_ptr=UINT(**{'sizeinbytes': 2}) 
2323          self.__field_downloaddomain_ptr.readfrombuffer(buf) 
2324          self.__field_num7=DATA(**{'sizeinbytes': 8}) 
2325          self.__field_num7.readfrombuffer(buf) 
2326          self.__field_filetype=UINT(**{'sizeinbytes': 2}) 
2327          self.__field_filetype.readfrombuffer(buf) 
2328          self.__field_num8=DATA(**{'sizeinbytes': 2}) 
2329          self.__field_num8.readfrombuffer(buf) 
2330          self.__field_mimetype_ptr=UINT(**{'sizeinbytes': 2}) 
2331          self.__field_mimetype_ptr.readfrombuffer(buf) 
2332          self.__field_num12=DATA(**{'sizeinbytes': 10}) 
2333          self.__field_num12.readfrombuffer(buf) 
2334          self._bufferendoffset=buf.getcurrentoffset() 
2335   
2336   
2337 -    def __getfield_dir_ptr(self): 
2338          return self.__field_dir_ptr.getvalue() 
2339   
2340 -    def __setfield_dir_ptr(self, value): 
2341          if isinstance(value,UINT): 
2342              self.__field_dir_ptr=value 
2343          else: 
2344              self.__field_dir_ptr=UINT(value,**{'sizeinbytes': 2}) 
2345   
2346 -    def __delfield_dir_ptr(self): del self.__field_dir_ptr 
2347   
2348      dir_ptr=property(__getfield_dir_ptr, __setfield_dir_ptr, __delfield_dir_ptr, None) 
2349   
2350 -    def __getfield_num2(self): 
2351          return self.__field_num2.getvalue() 
2352   
2353 -    def __setfield_num2(self, value): 
2354          if isinstance(value,UINT): 
2355              self.__field_num2=value 
2356          else: 
2357              self.__field_num2=UINT(value,**{'sizeinbytes': 2}) 
2358   
2359 -    def __delfield_num2(self): del self.__field_num2 
2360   
2361      num2=property(__getfield_num2, __setfield_num2, __delfield_num2, None) 
2362   
2363 -    def __getfield_name_ptr(self): 
2364          return self.__field_name_ptr.getvalue() 
2365   
2366 -    def __setfield_name_ptr(self, value): 
2367          if isinstance(value,UINT): 
2368              self.__field_name_ptr=value 
2369          else: 
2370              self.__field_name_ptr=UINT(value,**{'sizeinbytes': 2}) 
2371   
2372 -    def __delfield_name_ptr(self): del self.__field_name_ptr 
2373   
2374      name_ptr=property(__getfield_name_ptr, __setfield_name_ptr, __delfield_name_ptr, None) 
2375   
2376 -    def __getfield_version_ptr(self): 
2377          return self.__field_version_ptr.getvalue() 
2378   
2379 -    def __setfield_version_ptr(self, value): 
2380          if isinstance(value,UINT): 
2381              self.__field_version_ptr=value 
2382          else: 
2383              self.__field_version_ptr=UINT(value,**{'sizeinbytes': 2}) 
2384   
2385 -    def __delfield_version_ptr(self): del self.__field_version_ptr 
2386   
2387      version_ptr=property(__getfield_version_ptr, __setfield_version_ptr, __delfield_version_ptr, None) 
2388   
2389 -    def __getfield_vendor_ptr(self): 
2390          return self.__field_vendor_ptr.getvalue() 
2391   
2392 -    def __setfield_vendor_ptr(self, value): 
2393          if isinstance(value,UINT): 
2394              self.__field_vendor_ptr=value 
2395          else: 
2396              self.__field_vendor_ptr=UINT(value,**{'sizeinbytes': 2}) 
2397   
2398 -    def __delfield_vendor_ptr(self): del self.__field_vendor_ptr 
2399   
2400      vendor_ptr=property(__getfield_vendor_ptr, __setfield_vendor_ptr, __delfield_vendor_ptr, None) 
2401   
2402 -    def __getfield_downloaddomain_ptr(self): 
2403          return self.__field_downloaddomain_ptr.getvalue() 
2404   
2405 -    def __setfield_downloaddomain_ptr(self, value): 
2406          if isinstance(value,UINT): 
2407              self.__field_downloaddomain_ptr=value 
2408          else: 
2409              self.__field_downloaddomain_ptr=UINT(value,**{'sizeinbytes': 2}) 
2410   
2411 -    def __delfield_downloaddomain_ptr(self): del self.__field_downloaddomain_ptr 
2412   
2413      downloaddomain_ptr=property(__getfield_downloaddomain_ptr, __setfield_downloaddomain_ptr, __delfield_downloaddomain_ptr, None) 
2414   
2415 -    def __getfield_num7(self): 
2416          return self.__field_num7.getvalue() 
2417   
2418 -    def __setfield_num7(self, value): 
2419          if isinstance(value,DATA): 
2420              self.__field_num7=value 
2421          else: 
2422              self.__field_num7=DATA(value,**{'sizeinbytes': 8}) 
2423   
2424 -    def __delfield_num7(self): del self.__field_num7 
2425   
2426      num7=property(__getfield_num7, __setfield_num7, __delfield_num7, None) 
2427   
2428 -    def __getfield_filetype(self): 
2429          return self.__field_filetype.getvalue() 
2430   
2431 -    def __setfield_filetype(self, value): 
2432          if isinstance(value,UINT): 
2433              self.__field_filetype=value 
2434          else: 
2435              self.__field_filetype=UINT(value,**{'sizeinbytes': 2}) 
2436   
2437 -    def __delfield_filetype(self): del self.__field_filetype 
2438   
2439      filetype=property(__getfield_filetype, __setfield_filetype, __delfield_filetype, "12: Ringer, 13 Screen Saver, 15 Apps") 
2440   
2441 -    def __getfield_num8(self): 
2442          return self.__field_num8.getvalue() 
2443   
2444 -    def __setfield_num8(self, value): 
2445          if isinstance(value,DATA): 
2446              self.__field_num8=value 
2447          else: 
2448              self.__field_num8=DATA(value,**{'sizeinbytes': 2}) 
2449   
2450 -    def __delfield_num8(self): del self.__field_num8 
2451   
2452      num8=property(__getfield_num8, __setfield_num8, __delfield_num8, None) 
2453   
2454 -    def __getfield_mimetype_ptr(self): 
2455          return self.__field_mimetype_ptr.getvalue() 
2456   
2457 -    def __setfield_mimetype_ptr(self, value): 
2458          if isinstance(value,UINT): 
2459              self.__field_mimetype_ptr=value 
2460          else: 
2461              self.__field_mimetype_ptr=UINT(value,**{'sizeinbytes': 2}) 
2462   
2463 -    def __delfield_mimetype_ptr(self): del self.__field_mimetype_ptr 
2464   
2465      mimetype_ptr=property(__getfield_mimetype_ptr, __setfield_mimetype_ptr, __delfield_mimetype_ptr, None) 
2466   
2467 -    def __getfield_num12(self): 
2468          return self.__field_num12.getvalue() 
2469   
2470 -    def __setfield_num12(self, value): 
2471          if isinstance(value,DATA): 
2472              self.__field_num12=value 
2473          else: 
2474              self.__field_num12=DATA(value,**{'sizeinbytes': 10}) 
2475   
2476 -    def __delfield_num12(self): del self.__field_num12 
2477   
2478      num12=property(__getfield_num12, __setfield_num12, __delfield_num12, None) 
2479   
2480 -    def iscontainer(self): 
2481          return True 
2482   
2483 -    def containerelements(self): 
2484          yield ('dir_ptr', self.__field_dir_ptr, None) 
2485          yield ('num2', self.__field_num2, None) 
2486          yield ('name_ptr', self.__field_name_ptr, None) 
2487          yield ('version_ptr', self.__field_version_ptr, None) 
2488          yield ('vendor_ptr', self.__field_vendor_ptr, None) 
2489          yield ('downloaddomain_ptr', self.__field_downloaddomain_ptr, None) 
2490          yield ('num7', self.__field_num7, None) 
2491          yield ('filetype', self.__field_filetype, "12: Ringer, 13 Screen Saver, 15 Apps") 
2492          yield ('num8', self.__field_num8, None) 
2493          yield ('mimetype_ptr', self.__field_mimetype_ptr, None) 
2494          yield ('num12', self.__field_num12, None) 
2495   
2496   
2497   
2498   
2499 -class CamFile(BaseProtogenClass): 
2500      __fields=['dunno0', 'dunno1', 'caption', 'dunno2', 'dunno3', 'datetime', 'dunno4', 'pad', 'jpeg'] 
2501   
2502 -    def __init__(self, *args, **kwargs): 
2503          dict={} 
2504          # What was supplied to this function 
2505          dict.update(kwargs) 
2506          # Parent constructor 
2507          super(CamFile,self).__init__(**dict) 
2508          if self.__class__ is CamFile: 
2509              self._update(args,dict) 
2510   
2511   
2512 -    def getfields(self): 
2513          return self.__fields 
2514   
2515   
2516 -    def _update(self, args, kwargs): 
2517          super(CamFile,self)._update(args,kwargs) 
2518          keys=kwargs.keys() 
2519          for key in keys: 
2520              if key in self.__fields: 
2521                  setattr(self, key, kwargs[key]) 
2522                  del kwargs[key] 
2523          # Were any unrecognized kwargs passed in? 
2524          if __debug__: 
2525              self._complainaboutunusedargs(CamFile,kwargs) 
2526          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2527          # Make all P fields that haven't already been constructed 
2528   
2529   
2530 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2531          'Writes this packet to the supplied buffer' 
2532          self._bufferstartoffset=buf.getcurrentoffset() 
2533          self.__field_dunno0.writetobuffer(buf) 
2534          self.__field_dunno1.writetobuffer(buf) 
2535          self.__field_caption.writetobuffer(buf) 
2536          self.__field_dunno2.writetobuffer(buf) 
2537          self.__field_dunno3.writetobuffer(buf) 
2538          self.__field_datetime.writetobuffer(buf) 
2539          self.__field_dunno4.writetobuffer(buf) 
2540          self.__field_pad.writetobuffer(buf) 
2541          self.__field_jpeg.writetobuffer(buf) 
2542          self._bufferendoffset=buf.getcurrentoffset() 
2543          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2544   
2545   
2546 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2547          'Reads this packet from the supplied buffer' 
2548          self._bufferstartoffset=buf.getcurrentoffset() 
2549          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2550          self.__field_dunno0=UINT(**{'sizeinbytes': 4}) 
2551          self.__field_dunno0.readfrombuffer(buf) 
2552          self.__field_dunno1=UINT(**{'sizeinbytes': 1}) 
2553          self.__field_dunno1.readfrombuffer(buf) 
2554          self.__field_caption=USTRING(**{'sizeinbytes': 16,  'pascal': True,                 'terminator': None}) 
2555          self.__field_caption.readfrombuffer(buf) 
2556          self.__field_dunno2=UINT(**{'sizeinbytes': 1}) 
2557          self.__field_dunno2.readfrombuffer(buf) 
2558          self.__field_dunno3=DATA(**{'sizeinbytes': 2}) 
2559          self.__field_dunno3.readfrombuffer(buf) 
2560          self.__field_datetime=DateTime(**{'sizeinbytes': 4}) 
2561          self.__field_datetime.readfrombuffer(buf) 
2562          self.__field_dunno4=UINT(**{'sizeinbytes': 1}) 
2563          self.__field_dunno4.readfrombuffer(buf) 
2564          self.__field_pad=DATA(**{'sizeinbytes': 99}) 
2565          self.__field_pad.readfrombuffer(buf) 
2566          self.__field_jpeg=DATA() 
2567          self.__field_jpeg.readfrombuffer(buf) 
2568          self._bufferendoffset=buf.getcurrentoffset() 
2569   
2570   
2571 -    def __getfield_dunno0(self): 
2572          return self.__field_dunno0.getvalue() 
2573   
2574 -    def __setfield_dunno0(self, value): 
2575          if isinstance(value,UINT): 
2576              self.__field_dunno0=value 
2577          else: 
2578              self.__field_dunno0=UINT(value,**{'sizeinbytes': 4}) 
2579   
2580 -    def __delfield_dunno0(self): del self.__field_dunno0 
2581   
2582      dunno0=property(__getfield_dunno0, __setfield_dunno0, __delfield_dunno0, None) 
2583   
2584 -    def __getfield_dunno1(self): 
2585          return self.__field_dunno1.getvalue() 
2586   
2587 -    def __setfield_dunno1(self, value): 
2588          if isinstance(value,UINT): 
2589              self.__field_dunno1=value 
2590          else: 
2591              self.__field_dunno1=UINT(value,**{'sizeinbytes': 1}) 
2592   
2593 -    def __delfield_dunno1(self): del self.__field_dunno1 
2594   
2595      dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None) 
2596   
2597 -    def __getfield_caption(self): 
2598          return self.__field_caption.getvalue() 
2599   
2600 -    def __setfield_caption(self, value): 
2601          if isinstance(value,USTRING): 
2602              self.__field_caption=value 
2603          else: 
2604              self.__field_caption=USTRING(value,**{'sizeinbytes': 16,  'pascal': True,                 'terminator': None}) 
2605   
2606 -    def __delfield_caption(self): del self.__field_caption 
2607   
2608      caption=property(__getfield_caption, __setfield_caption, __delfield_caption, None) 
2609   
2610 -    def __getfield_dunno2(self): 
2611          return self.__field_dunno2.getvalue() 
2612   
2613 -    def __setfield_dunno2(self, value): 
2614          if isinstance(value,UINT): 
2615              self.__field_dunno2=value 
2616          else: 
2617              self.__field_dunno2=UINT(value,**{'sizeinbytes': 1}) 
2618   
2619 -    def __delfield_dunno2(self): del self.__field_dunno2 
2620   
2621      dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None) 
2622   
2623 -    def __getfield_dunno3(self): 
2624          return self.__field_dunno3.getvalue() 
2625   
2626 -    def __setfield_dunno3(self, value): 
2627          if isinstance(value,DATA): 
2628              self.__field_dunno3=value 
2629          else: 
2630              self.__field_dunno3=DATA(value,**{'sizeinbytes': 2}) 
2631   
2632 -    def __delfield_dunno3(self): del self.__field_dunno3 
2633   
2634      dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None) 
2635   
2636 -    def __getfield_datetime(self): 
2637          return self.__field_datetime.getvalue() 
2638   
2639 -    def __setfield_datetime(self, value): 
2640          if isinstance(value,DateTime): 
2641              self.__field_datetime=value 
2642          else: 
2643              self.__field_datetime=DateTime(value,**{'sizeinbytes': 4}) 
2644   
2645 -    def __delfield_datetime(self): del self.__field_datetime 
2646   
2647      datetime=property(__getfield_datetime, __setfield_datetime, __delfield_datetime, None) 
2648   
2649 -    def __getfield_dunno4(self): 
2650          return self.__field_dunno4.getvalue() 
2651   
2652 -    def __setfield_dunno4(self, value): 
2653          if isinstance(value,UINT): 
2654              self.__field_dunno4=value 
2655          else: 
2656              self.__field_dunno4=UINT(value,**{'sizeinbytes': 1}) 
2657   
2658 -    def __delfield_dunno4(self): del self.__field_dunno4 
2659   
2660      dunno4=property(__getfield_dunno4, __setfield_dunno4, __delfield_dunno4, None) 
2661   
2662 -    def __getfield_pad(self): 
2663          return self.__field_pad.getvalue() 
2664   
2665 -    def __setfield_pad(self, value): 
2666          if isinstance(value,DATA): 
2667              self.__field_pad=value 
2668          else: 
2669              self.__field_pad=DATA(value,**{'sizeinbytes': 99}) 
2670   
2671 -    def __delfield_pad(self): del self.__field_pad 
2672   
2673      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
2674   
2675 -    def __getfield_jpeg(self): 
2676          return self.__field_jpeg.getvalue() 
2677   
2678 -    def __setfield_jpeg(self, value): 
2679          if isinstance(value,DATA): 
2680              self.__field_jpeg=value 
2681          else: 
2682              self.__field_jpeg=DATA(value,) 
2683   
2684 -    def __delfield_jpeg(self): del self.__field_jpeg 
2685   
2686      jpeg=property(__getfield_jpeg, __setfield_jpeg, __delfield_jpeg, None) 
2687   
2688 -    def iscontainer(self): 
2689          return True 
2690   
2691 -    def containerelements(self): 
2692          yield ('dunno0', self.__field_dunno0, None) 
2693          yield ('dunno1', self.__field_dunno1, None) 
2694          yield ('caption', self.__field_caption, None) 
2695          yield ('dunno2', self.__field_dunno2, None) 
2696          yield ('dunno3', self.__field_dunno3, None) 
2697          yield ('datetime', self.__field_datetime, None) 
2698          yield ('dunno4', self.__field_dunno4, None) 
2699          yield ('pad', self.__field_pad, None) 
2700          yield ('jpeg', self.__field_jpeg, None) 
2701   
2702 -    def _filename(self): 
2703          return '%(year)04d%(month)02d%(day)02d_%(name)s.jpg'%\ 
2704                 { 'year': self.datetime[0], 
2705                   'month': self.datetime[1], 
2706                   'day': self.datetime[2], 
2707                   'name': self.caption, 
2708                   } 
2709      filename=property(fget=_filename) 
2710 -    def save(self, filename=None): 
2711          # save the jpeg data to a file         
2712          return file(filename if filename else self.filename, 'wb').write(self.jpeg) 
2713   
2714   
2715   
2716   
2717 -class IndexSlot(BaseProtogenClass): 
2718      __fields=['valid', 'group', 'index'] 
2719   
2720 -    def __init__(self, *args, **kwargs): 
2721          dict={} 
2722          # What was supplied to this function 
2723          dict.update(kwargs) 
2724          # Parent constructor 
2725          super(IndexSlot,self).__init__(**dict) 
2726          if self.__class__ is IndexSlot: 
2727              self._update(args,dict) 
2728   
2729   
2730 -    def getfields(self): 
2731          return self.__fields 
2732   
2733   
2734 -    def _update(self, args, kwargs): 
2735          super(IndexSlot,self)._update(args,kwargs) 
2736          keys=kwargs.keys() 
2737          for key in keys: 
2738              if key in self.__fields: 
2739                  setattr(self, key, kwargs[key]) 
2740                  del kwargs[key] 
2741          # Were any unrecognized kwargs passed in? 
2742          if __debug__: 
2743              self._complainaboutunusedargs(IndexSlot,kwargs) 
2744          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2745          # Make all P fields that haven't already been constructed 
2746   
2747   
2748 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2749          'Writes this packet to the supplied buffer' 
2750          self._bufferstartoffset=buf.getcurrentoffset() 
2751          try: self.__field_valid 
2752          except: 
2753              self.__field_valid=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
2754          self.__field_valid.writetobuffer(buf) 
2755          try: self.__field_group 
2756          except: 
2757              self.__field_group=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
2758          self.__field_group.writetobuffer(buf) 
2759          try: self.__field_index 
2760          except: 
2761              self.__field_index=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
2762          self.__field_index.writetobuffer(buf) 
2763          self._bufferendoffset=buf.getcurrentoffset() 
2764          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2765   
2766   
2767 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2768          'Reads this packet from the supplied buffer' 
2769          self._bufferstartoffset=buf.getcurrentoffset() 
2770          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2771          self.__field_valid=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
2772          self.__field_valid.readfrombuffer(buf) 
2773          self.__field_group=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
2774          self.__field_group.readfrombuffer(buf) 
2775          self.__field_index=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
2776          self.__field_index.readfrombuffer(buf) 
2777          self._bufferendoffset=buf.getcurrentoffset() 
2778   
2779   
2780 -    def __getfield_valid(self): 
2781          try: self.__field_valid 
2782          except: 
2783              self.__field_valid=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
2784          return self.__field_valid.getvalue() 
2785   
2786 -    def __setfield_valid(self, value): 
2787          if isinstance(value,UINT): 
2788              self.__field_valid=value 
2789          else: 
2790              self.__field_valid=UINT(value,**{'sizeinbytes': 1,  'default': 0 }) 
2791   
2792 -    def __delfield_valid(self): del self.__field_valid 
2793   
2794      valid=property(__getfield_valid, __setfield_valid, __delfield_valid, "=1 if valid slot") 
2795   
2796 -    def __getfield_group(self): 
2797          try: self.__field_group 
2798          except: 
2799              self.__field_group=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
2800          return self.__field_group.getvalue() 
2801   
2802 -    def __setfield_group(self, value): 
2803          if isinstance(value,UINT): 
2804              self.__field_group=value 
2805          else: 
2806              self.__field_group=UINT(value,**{'sizeinbytes': 1,  'default': 0 }) 
2807   
2808 -    def __delfield_group(self): del self.__field_group 
2809   
2810      group=property(__getfield_group, __setfield_group, __delfield_group, "Group Index") 
2811   
2812 -    def __getfield_index(self): 
2813          try: self.__field_index 
2814          except: 
2815              self.__field_index=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
2816          return self.__field_index.getvalue() 
2817   
2818 -    def __setfield_index(self, value): 
2819          if isinstance(value,UINT): 
2820              self.__field_index=value 
2821          else: 
2822              self.__field_index=UINT(value,**{'sizeinbytes': 1,  'default': 0 }) 
2823   
2824 -    def __delfield_index(self): del self.__field_index 
2825   
2826      index=property(__getfield_index, __setfield_index, __delfield_index, "Media Index") 
2827   
2828 -    def iscontainer(self): 
2829          return True 
2830   
2831 -    def containerelements(self): 
2832          yield ('valid', self.__field_valid, "=1 if valid slot") 
2833          yield ('group', self.__field_group, "Group Index") 
2834          yield ('index', self.__field_index, "Media Index") 
2835   
2836   
2837   
2838   
2839 -class IndexFile(BaseProtogenClass): 
2840      __fields=['entry'] 
2841   
2842 -    def __init__(self, *args, **kwargs): 
2843          dict={} 
2844          # What was supplied to this function 
2845          dict.update(kwargs) 
2846          # Parent constructor 
2847          super(IndexFile,self).__init__(**dict) 
2848          if self.__class__ is IndexFile: 
2849              self._update(args,dict) 
2850   
2851   
2852 -    def getfields(self): 
2853          return self.__fields 
2854   
2855   
2856 -    def _update(self, args, kwargs): 
2857          super(IndexFile,self)._update(args,kwargs) 
2858          keys=kwargs.keys() 
2859          for key in keys: 
2860              if key in self.__fields: 
2861                  setattr(self, key, kwargs[key]) 
2862                  del kwargs[key] 
2863          # Were any unrecognized kwargs passed in? 
2864          if __debug__: 
2865              self._complainaboutunusedargs(IndexFile,kwargs) 
2866          if len(args): 
2867              dict2={ 'elementclass': IndexSlot,             'length': max_media_index_entries,             'createdefault': True } 
2868              dict2.update(kwargs) 
2869              kwargs=dict2 
2870              self.__field_entry=LIST(*args,**dict2) 
2871          # Make all P fields that haven't already been constructed 
2872   
2873   
2874 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2875          'Writes this packet to the supplied buffer' 
2876          self._bufferstartoffset=buf.getcurrentoffset() 
2877          try: self.__field_entry 
2878          except: 
2879              self.__field_entry=LIST(**{ 'elementclass': IndexSlot,             'length': max_media_index_entries,             'createdefault': True }) 
2880          self.__field_entry.writetobuffer(buf) 
2881          self._bufferendoffset=buf.getcurrentoffset() 
2882          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2883   
2884   
2885 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2886          'Reads this packet from the supplied buffer' 
2887          self._bufferstartoffset=buf.getcurrentoffset() 
2888          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2889          self.__field_entry=LIST(**{ 'elementclass': IndexSlot,             'length': max_media_index_entries,             'createdefault': True }) 
2890          self.__field_entry.readfrombuffer(buf) 
2891          self._bufferendoffset=buf.getcurrentoffset() 
2892   
2893   
2894 -    def __getfield_entry(self): 
2895          try: self.__field_entry 
2896          except: 
2897              self.__field_entry=LIST(**{ 'elementclass': IndexSlot,             'length': max_media_index_entries,             'createdefault': True }) 
2898          return self.__field_entry.getvalue() 
2899   
2900 -    def __setfield_entry(self, value): 
2901          if isinstance(value,LIST): 
2902              self.__field_entry=value 
2903          else: 
2904              self.__field_entry=LIST(value,**{ 'elementclass': IndexSlot,             'length': max_media_index_entries,             'createdefault': True }) 
2905   
2906 -    def __delfield_entry(self): del self.__field_entry 
2907   
2908      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
2909   
2910 -    def iscontainer(self): 
2911          return True 
2912   
2913 -    def containerelements(self): 
2914          yield ('entry', self.__field_entry, None) 
2915   
2916   
2917   
2918   
2919 -class Group(BaseProtogenClass): 
2920      __fields=['num0', 'num1', 'namelen', 'namestr', 'num5', 'dunno', 'nume3', 'datetime', 'num4'] 
2921   
2922 -    def __init__(self, *args, **kwargs): 
2923          dict={} 
2924          # What was supplied to this function 
2925          dict.update(kwargs) 
2926          # Parent constructor 
2927          super(Group,self).__init__(**dict) 
2928          if self.__class__ is Group: 
2929              self._update(args,dict) 
2930   
2931   
2932 -    def getfields(self): 
2933          return self.__fields 
2934   
2935   
2936 -    def _update(self, args, kwargs): 
2937          super(Group,self)._update(args,kwargs) 
2938          keys=kwargs.keys() 
2939          for key in keys: 
2940              if key in self.__fields: 
2941                  setattr(self, key, kwargs[key]) 
2942                  del kwargs[key] 
2943          # Were any unrecognized kwargs passed in? 
2944          if __debug__: 
2945              self._complainaboutunusedargs(Group,kwargs) 
2946          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2947          # Make all P fields that haven't already been constructed 
2948   
2949   
2950 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2951          'Writes this packet to the supplied buffer' 
2952          self._bufferstartoffset=buf.getcurrentoffset() 
2953          try: self.__field_num0 
2954          except: 
2955              self.__field_num0=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
2956          self.__field_num0.writetobuffer(buf) 
2957          try: self.__field_num1 
2958          except: 
2959              self.__field_num1=UINT(**{'sizeinbytes': 1,  'default': 1 if self.num0 else 0 }) 
2960          self.__field_num1.writetobuffer(buf) 
2961          try: self.__field_namelen 
2962          except: 
2963              self.__field_namelen=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
2964          self.__field_namelen.writetobuffer(buf) 
2965          try: self.__field_namestr 
2966          except: 
2967              self.__field_namestr=USTRING(**{'sizeinbytes': 12,  'terminator': None,                 'default': '' }) 
2968          self.__field_namestr.writetobuffer(buf) 
2969          try: self.__field_num5 
2970          except: 
2971              self.__field_num5=UINT(**{'sizeinbytes': 1,  'default': 0x30 if self.num0 else 0 }) 
2972          self.__field_num5.writetobuffer(buf) 
2973          try: self.__field_dunno 
2974          except: 
2975              self.__field_dunno=DATA(**{'sizeinbytes': 8,  'default': '\x00'*8 }) 
2976          self.__field_dunno.writetobuffer(buf) 
2977          try: self.__field_nume3 
2978          except: 
2979              self.__field_nume3=UINT(**{'sizeinbytes': 1,  'default': 1 if self.num0 else 0 }) 
2980          self.__field_nume3.writetobuffer(buf) 
2981          if self.num0: 
2982              try: self.__field_datetime 
2983              except: 
2984                  self.__field_datetime=DateTime(**{'sizeinbytes': 4,  'default': DateTime.now() }) 
2985              self.__field_datetime.writetobuffer(buf) 
2986          else: 
2987              try: self.__field_num4 
2988              except: 
2989                  self.__field_num4=UINT(**{'sizeinbytes': 4,  'default': 0 }) 
2990              self.__field_num4.writetobuffer(buf) 
2991          self._bufferendoffset=buf.getcurrentoffset() 
2992          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2993   
2994   
2995 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2996          'Reads this packet from the supplied buffer' 
2997          self._bufferstartoffset=buf.getcurrentoffset() 
2998          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2999          self.__field_num0=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
3000          self.__field_num0.readfrombuffer(buf) 
3001          self.__field_num1=UINT(**{'sizeinbytes': 1,  'default': 1 if self.num0 else 0 }) 
3002          self.__field_num1.readfrombuffer(buf) 
3003          self.__field_namelen=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
3004          self.__field_namelen.readfrombuffer(buf) 
3005          self.__field_namestr=USTRING(**{'sizeinbytes': 12,  'terminator': None,                 'default': '' }) 
3006          self.__field_namestr.readfrombuffer(buf) 
3007          self.__field_num5=UINT(**{'sizeinbytes': 1,  'default': 0x30 if self.num0 else 0 }) 
3008          self.__field_num5.readfrombuffer(buf) 
3009          self.__field_dunno=DATA(**{'sizeinbytes': 8,  'default': '\x00'*8 }) 
3010          self.__field_dunno.readfrombuffer(buf) 
3011          self.__field_nume3=UINT(**{'sizeinbytes': 1,  'default': 1 if self.num0 else 0 }) 
3012          self.__field_nume3.readfrombuffer(buf) 
3013          if self.num0: 
3014              self.__field_datetime=DateTime(**{'sizeinbytes': 4,  'default': DateTime.now() }) 
3015              self.__field_datetime.readfrombuffer(buf) 
3016          else: 
3017              self.__field_num4=UINT(**{'sizeinbytes': 4,  'default': 0 }) 
3018              self.__field_num4.readfrombuffer(buf) 
3019          self._bufferendoffset=buf.getcurrentoffset() 
3020   
3021   
3022 -    def __getfield_num0(self): 
3023          try: self.__field_num0 
3024          except: 
3025              self.__field_num0=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
3026          return self.__field_num0.getvalue() 
3027   
3028 -    def __setfield_num0(self, value): 
3029          if isinstance(value,UINT): 
3030              self.__field_num0=value 
3031          else: 
3032              self.__field_num0=UINT(value,**{'sizeinbytes': 1,  'default': 0 }) 
3033   
3034 -    def __delfield_num0(self): del self.__field_num0 
3035   
3036      num0=property(__getfield_num0, __setfield_num0, __delfield_num0, None) 
3037   
3038 -    def __getfield_num1(self): 
3039          try: self.__field_num1 
3040          except: 
3041              self.__field_num1=UINT(**{'sizeinbytes': 1,  'default': 1 if self.num0 else 0 }) 
3042          return self.__field_num1.getvalue() 
3043   
3044 -    def __setfield_num1(self, value): 
3045          if isinstance(value,UINT): 
3046              self.__field_num1=value 
3047          else: 
3048              self.__field_num1=UINT(value,**{'sizeinbytes': 1,  'default': 1 if self.num0 else 0 }) 
3049   
3050 -    def __delfield_num1(self): del self.__field_num1 
3051   
3052      num1=property(__getfield_num1, __setfield_num1, __delfield_num1, None) 
3053   
3054 -    def __getfield_namelen(self): 
3055          try: self.__field_namelen 
3056          except: 
3057              self.__field_namelen=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
3058          return self.__field_namelen.getvalue() 
3059   
3060 -    def __setfield_namelen(self, value): 
3061          if isinstance(value,UINT): 
3062              self.__field_namelen=value 
3063          else: 
3064              self.__field_namelen=UINT(value,**{'sizeinbytes': 2,  'default': 0 }) 
3065   
3066 -    def __delfield_namelen(self): del self.__field_namelen 
3067   
3068      namelen=property(__getfield_namelen, __setfield_namelen, __delfield_namelen, None) 
3069   
3070 -    def __getfield_namestr(self): 
3071          try: self.__field_namestr 
3072          except: 
3073              self.__field_namestr=USTRING(**{'sizeinbytes': 12,  'terminator': None,                 'default': '' }) 
3074          return self.__field_namestr.getvalue() 
3075   
3076 -    def __setfield_namestr(self, value): 
3077          if isinstance(value,USTRING): 
3078              self.__field_namestr=value 
3079          else: 
3080              self.__field_namestr=USTRING(value,**{'sizeinbytes': 12,  'terminator': None,                 'default': '' }) 
3081   
3082 -    def __delfield_namestr(self): del self.__field_namestr 
3083   
3084      namestr=property(__getfield_namestr, __setfield_namestr, __delfield_namestr, None) 
3085   
3086 -    def __getfield_num5(self): 
3087          try: self.__field_num5 
3088          except: 
3089              self.__field_num5=UINT(**{'sizeinbytes': 1,  'default': 0x30 if self.num0 else 0 }) 
3090          return self.__field_num5.getvalue() 
3091   
3092 -    def __setfield_num5(self, value): 
3093          if isinstance(value,UINT): 
3094              self.__field_num5=value 
3095          else: 
3096              self.__field_num5=UINT(value,**{'sizeinbytes': 1,  'default': 0x30 if self.num0 else 0 }) 
3097   
3098 -    def __delfield_num5(self): del self.__field_num5 
3099   
3100      num5=property(__getfield_num5, __setfield_num5, __delfield_num5, None) 
3101   
3102 -    def __getfield_dunno(self): 
3103          try: self.__field_dunno 
3104          except: 
3105              self.__field_dunno=DATA(**{'sizeinbytes': 8,  'default': '\x00'*8 }) 
3106          return self.__field_dunno.getvalue() 
3107   
3108 -    def __setfield_dunno(self, value): 
3109          if isinstance(value,DATA): 
3110              self.__field_dunno=value 
3111          else: 
3112              self.__field_dunno=DATA(value,**{'sizeinbytes': 8,  'default': '\x00'*8 }) 
3113   
3114 -    def __delfield_dunno(self): del self.__field_dunno 
3115   
3116      dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, None) 
3117   
3118 -    def __getfield_nume3(self): 
3119          try: self.__field_nume3 
3120          except: 
3121              self.__field_nume3=UINT(**{'sizeinbytes': 1,  'default': 1 if self.num0 else 0 }) 
3122          return self.__field_nume3.getvalue() 
3123   
3124 -    def __setfield_nume3(self, value): 
3125          if isinstance(value,UINT): 
3126              self.__field_nume3=value 
3127          else: 
3128              self.__field_nume3=UINT(value,**{'sizeinbytes': 1,  'default': 1 if self.num0 else 0 }) 
3129   
3130 -    def __delfield_nume3(self): del self.__field_nume3 
3131   
3132      nume3=property(__getfield_nume3, __setfield_nume3, __delfield_nume3, None) 
3133   
3134 -    def __getfield_datetime(self): 
3135          try: self.__field_datetime 
3136          except: 
3137              self.__field_datetime=DateTime(**{'sizeinbytes': 4,  'default': DateTime.now() }) 
3138          return self.__field_datetime.getvalue() 
3139   
3140 -    def __setfield_datetime(self, value): 
3141          if isinstance(value,DateTime): 
3142              self.__field_datetime=value 
3143          else: 
3144              self.__field_datetime=DateTime(value,**{'sizeinbytes': 4,  'default': DateTime.now() }) 
3145   
3146 -    def __delfield_datetime(self): del self.__field_datetime 
3147   
3148      datetime=property(__getfield_datetime, __setfield_datetime, __delfield_datetime, None) 
3149   
3150 -    def __getfield_num4(self): 
3151          try: self.__field_num4 
3152          except: 
3153              self.__field_num4=UINT(**{'sizeinbytes': 4,  'default': 0 }) 
3154          return self.__field_num4.getvalue() 
3155   
3156 -    def __setfield_num4(self, value): 
3157          if isinstance(value,UINT): 
3158              self.__field_num4=value 
3159          else: 
3160              self.__field_num4=UINT(value,**{'sizeinbytes': 4,  'default': 0 }) 
3161   
3162 -    def __delfield_num4(self): del self.__field_num4 
3163   
3164      num4=property(__getfield_num4, __setfield_num4, __delfield_num4, None) 
3165   
3166 -    def iscontainer(self): 
3167          return True 
3168   
3169 -    def containerelements(self): 
3170          yield ('num0', self.__field_num0, None) 
3171          yield ('num1', self.__field_num1, None) 
3172          yield ('namelen', self.__field_namelen, None) 
3173          yield ('namestr', self.__field_namestr, None) 
3174          yield ('num5', self.__field_num5, None) 
3175          yield ('dunno', self.__field_dunno, None) 
3176          yield ('nume3', self.__field_nume3, None) 
3177          if self.num0: 
3178              yield ('datetime', self.__field_datetime, None) 
3179          else: 
3180              yield ('num4', self.__field_num4, None) 
3181   
3182 -    def _get_name(self): 
3183          return self.namestr[:self.namelen] if self.namelen else "" 
3184      name=property(fget=_get_name) 
3185   
3186   
3187   
3188   
3189 -class GroupFile(BaseProtogenClass): 
3190      __fields=['entry'] 
3191   
3192 -    def __init__(self, *args, **kwargs): 
3193          dict={} 
3194          # What was supplied to this function 
3195          dict.update(kwargs) 
3196          # Parent constructor 
3197          super(GroupFile,self).__init__(**dict) 
3198          if self.__class__ is GroupFile: 
3199              self._update(args,dict) 
3200   
3201   
3202 -    def getfields(self): 
3203          return self.__fields 
3204   
3205   
3206 -    def _update(self, args, kwargs): 
3207          super(GroupFile,self)._update(args,kwargs) 
3208          keys=kwargs.keys() 
3209          for key in keys: 
3210              if key in self.__fields: 
3211                  setattr(self, key, kwargs[key]) 
3212                  del kwargs[key] 
3213          # Were any unrecognized kwargs passed in? 
3214          if __debug__: 
3215              self._complainaboutunusedargs(GroupFile,kwargs) 
3216          if len(args): 
3217              dict2={ 'elementclass': Group,             'length': max_group_entries,             'createdefault': True } 
3218              dict2.update(kwargs) 
3219              kwargs=dict2 
3220              self.__field_entry=LIST(*args,**dict2) 
3221          # Make all P fields that haven't already been constructed 
3222   
3223   
3224 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3225          'Writes this packet to the supplied buffer' 
3226          self._bufferstartoffset=buf.getcurrentoffset() 
3227          try: self.__field_entry 
3228          except: 
3229              self.__field_entry=LIST(**{ 'elementclass': Group,             'length': max_group_entries,             'createdefault': True }) 
3230          self.__field_entry.writetobuffer(buf) 
3231          self._bufferendoffset=buf.getcurrentoffset() 
3232          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3233   
3234   
3235 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3236          'Reads this packet from the supplied buffer' 
3237          self._bufferstartoffset=buf.getcurrentoffset() 
3238          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3239          self.__field_entry=LIST(**{ 'elementclass': Group,             'length': max_group_entries,             'createdefault': True }) 
3240          self.__field_entry.readfrombuffer(buf) 
3241          self._bufferendoffset=buf.getcurrentoffset() 
3242   
3243   
3244 -    def __getfield_entry(self): 
3245          try: self.__field_entry 
3246          except: 
3247              self.__field_entry=LIST(**{ 'elementclass': Group,             'length': max_group_entries,             'createdefault': True }) 
3248          return self.__field_entry.getvalue() 
3249   
3250 -    def __setfield_entry(self, value): 
3251          if isinstance(value,LIST): 
3252              self.__field_entry=value 
3253          else: 
3254              self.__field_entry=LIST(value,**{ 'elementclass': Group,             'length': max_group_entries,             'createdefault': True }) 
3255   
3256 -    def __delfield_entry(self): del self.__field_entry 
3257   
3258      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
3259   
3260 -    def iscontainer(self): 
3261          return True 
3262   
3263 -    def containerelements(self): 
3264          yield ('entry', self.__field_entry, None) 
3265