Source Code for Module phones.p_samsungscha950

   1  # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE 
   2   
   3  """Various descriptions of data specific to the Samsung SCH-A950 Phone""" 
   4   
   5  from prototypes import * 
   6  from prototypes_samsung import * 
   7  from p_brew import * 
   8   
   9  # We use LSB for all integer like fields 
  10  UINT=UINTlsb 
  11  BOOL=BOOLlsb 
  12   
  13  ENCODING='latin_1' 
  14   
  15  RT_PATH='brew/16452/mr' 
  16  RT_PATH2='brew/16452/lk/mr' 
  17  RT_INDEX_FILE_NAME=RT_PATH+'/MrInfo.db' 
  18  RT_EXCLUDED_FILES=('MrInfo.db',) 
  19  SND_PATH='brew/16452/ms' 
  20  SND_PATH2='brew/16452/lk/ms' 
  21  SND_INDEX_FILE_NAME=SND_PATH+'/MsInfo.db' 
  22  SND_EXCLUDED_FILES=('MsInfo.db', 'ExInfo.db') 
  23  PIC_PATH='brew/16452/mp' 
  24  PIC_PATH2='brew/16452/lk/mp' 
  25  PIC_INDEX_FILE_NAME=PIC_PATH+'/Default Album.alb' 
  26  PIC_EXCLUDED_FILES=('Default Album.alb', 'Graphics.alb') 
  27  PREF_DB_FILE_NAME='current_prefs.db' 
  28   
  29  GROUP_INDEX_FILE_NAME='pb/pbgroups_' 
  30   
  31  # Calendar stuff 
  32  CAL_PATH='sch_event' 
  33  CAL_INDEX_FILE_NAME=CAL_PATH+'/usr_tsk' 
  34  CAL_FILE_NAME_PREFIX=CAL_PATH+'/usr_tsk_' 
  35  CAL_MAX_EVENTS=100 
  36   
  37  NP_MAX_ENTRIES=30 
  38  NP_MAX_LEN=130 
  39  NP_PATH=CAL_PATH 
  40  NP_FILE_NAME_PREFIX=CAL_FILE_NAME_PREFIX 
  41   
  42  # Phonebook stuff 
  43  PB_PATH='pb' 
  44  PB_JRNL_FILE_PREFIX=PB_PATH+'/jrnl_' 
  45  PB_ENTRY_FILE_PREFIX=PB_PATH+'/recs_' 
  46  PB_MAIN_FILE_PREFIX=PB_PATH+'/main_' 
  47  PB_WP_CACHE_PATH='cache/pb' 
  48  PB_WP_CACHE_WIDTH=128 
  49  PB_WP_CACHE_HEIGHT=96 
  50  PB_MAX_NAME_LEN=32 
  51  PB_MAX_EMAIL_LEN=48 
  52  PB_MAX_NUMBER_LEN=48 
  53   
  54  PB_FLG_NONE=0x0000 
  55  PB_FLG_NAME=0x0001 
  56  PB_FLG_DATE=0x0400 
  57  PB_FLG_FAX=0x0080 
  58  PB_FLG_CELL=0x0020 
  59  PB_FLG_WORK=0x0010 
  60  PB_FLG_HOME=0X0008 
  61  PB_FLG_EMAIL2=0X0004 
  62  PB_FLG_EMAIL=0X0002 
  63  PB_FLG_WP=0X8000 
  64  PB_FLG_GROUP=0X0800 
  65  PB_FLG_CELL2=0X0100 
  66  PB_FLG_SPEEDDIAL=0x01 
  67  PB_FLG_RINGTONE=0x10 
  68  PB_FLG_PRIMARY=0x02 
  69   
  70  # Samsung command code 
  71  SS_CMD_SW_VERSION=0 
  72  SS_CMD_HW_VERSION=1 
  73  SS_CMD_PB_COUNT=2 
  74  SS_CMD_PB_VOICEMAIL_READ=5 
  75  SS_CMD_PB_VOICEMAIL_WRITE=6 
  76  SS_CMD_PB_READ=0x14 
  77  SS_CMD_PB_WRITE=0x15 
  78  SS_CMD_PB_CLEAR=0x1D 
  79  SS_CMD_PB_VOICEMAIL_PARAM=0x19 
  80  PB_DEFAULT_VOICEMAIL_NUMBER='*86' 
  81   
  82  # Call log/history 
  83  CL_PATH='clog' 
  84  CL_PREFIX=CL_PATH+'/clog_' 
  85  CL_INDEX_FILE=CL_PATH+'/clog_master' 
  86  CL_MAX_ENTRIES=20 
  87  CL_TYPE_INCOMING=1 
  88  CL_TYPE_OUTGOING=2 
  89  CL_TYPE_MISSED=3 
  90  CL_TYPE_DELETED=5 
  91  CL_VALID_TYPE=frozenset((CL_TYPE_INCOMING, CL_TYPE_OUTGOING, CL_TYPE_MISSED)) 
  92   
  93  # SMS stuff 
  94  SMS_PATH='nvm/sms_wp_os' 
  95   
  96  SMS_TXT_TYPE=0x0200 
  97  SMS_TYPE_IN=1 
  98  SMS_TYPE_SENT=3 
  99  SMS_TYPE_DRAFT=4 
 100  SMS_VALID_TYPE=(SMS_TYPE_IN, SMS_TYPE_SENT, SMS_TYPE_DRAFT) 
 101  SMS_FLG1_DEFERREDDEL=0x40 
 102  SMS_FLG1_VALIDPERIOD=0x10 
 103  SMS_FLG1_HAS40=SMS_FLG1_DEFERREDDEL | SMS_FLG1_VALIDPERIOD 
 104  SMS_FLG2_CALLBACK=0x40 
 105  SMS_FLG2_MSG=0x04 
 106  SMS_FLG2_PRIORITY=0x01 
 107  SMS_FLG2_SOMETHING=0x08 
 108  SMS_STATUS_SENT=0x10 
 109  SMS_STATUS_DELIVERED=0x11 
 110  SMS_STATUS_READ=0x05 
 111  SMS_STATUS_NOTREAD=0x01 
 112  SMS_STATUS_LOCKED=0x100 
 113   
 114  broken_filelist_date=True 
 115 -class DefaultResponse(BaseProtogenClass): 
 116      __fields=['data'] 
 117   
 118 -    def __init__(self, *args, **kwargs): 
 119          dict={} 
 120          # What was supplied to this function 
 121          dict.update(kwargs) 
 122          # Parent constructor 
 123          super(DefaultResponse,self).__init__(**dict) 
 124          if self.__class__ is DefaultResponse: 
 125              self._update(args,dict) 
 126   
 127   
 128 -    def getfields(self): 
 129          return self.__fields 
 130   
 131   
 132 -    def _update(self, args, kwargs): 
 133          super(DefaultResponse,self)._update(args,kwargs) 
 134          keys=kwargs.keys() 
 135          for key in keys: 
 136              if key in self.__fields: 
 137                  setattr(self, key, kwargs[key]) 
 138                  del kwargs[key] 
 139          # Were any unrecognized kwargs passed in? 
 140          if __debug__: 
 141              self._complainaboutunusedargs(DefaultResponse,kwargs) 
 142          if len(args): 
 143              dict2={} 
 144              dict2.update(kwargs) 
 145              kwargs=dict2 
 146              self.__field_data=DATA(*args,**dict2) 
 147          # Make all P fields that haven't already been constructed 
 148   
 149   
 150 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 151          'Writes this packet to the supplied buffer' 
 152          self._bufferstartoffset=buf.getcurrentoffset() 
 153          self.__field_data.writetobuffer(buf) 
 154          self._bufferendoffset=buf.getcurrentoffset() 
 155          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 156   
 157   
 158 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 159          'Reads this packet from the supplied buffer' 
 160          self._bufferstartoffset=buf.getcurrentoffset() 
 161          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 162          self.__field_data=DATA() 
 163          self.__field_data.readfrombuffer(buf) 
 164          self._bufferendoffset=buf.getcurrentoffset() 
 165   
 166   
 167 -    def __getfield_data(self): 
 168          return self.__field_data.getvalue() 
 169   
 170 -    def __setfield_data(self, value): 
 171          if isinstance(value,DATA): 
 172              self.__field_data=value 
 173          else: 
 174              self.__field_data=DATA(value,) 
 175   
 176 -    def __delfield_data(self): del self.__field_data 
 177   
 178      data=property(__getfield_data, __setfield_data, __delfield_data, None) 
 179   
 180 -    def iscontainer(self): 
 181          return True 
 182   
 183 -    def containerelements(self): 
 184          yield ('data', self.__field_data, None) 
 185   
 186   
 187   
 188   
 189 -class WRingtoneIndexEntry(BaseProtogenClass): 
 190      __fields=['name', 'path_prefix', 'pathname', 'eor'] 
 191   
 192 -    def __init__(self, *args, **kwargs): 
 193          dict={} 
 194          # What was supplied to this function 
 195          dict.update(kwargs) 
 196          # Parent constructor 
 197          super(WRingtoneIndexEntry,self).__init__(**dict) 
 198          if self.__class__ is WRingtoneIndexEntry: 
 199              self._update(args,dict) 
 200   
 201   
 202 -    def getfields(self): 
 203          return self.__fields 
 204   
 205   
 206 -    def _update(self, args, kwargs): 
 207          super(WRingtoneIndexEntry,self)._update(args,kwargs) 
 208          keys=kwargs.keys() 
 209          for key in keys: 
 210              if key in self.__fields: 
 211                  setattr(self, key, kwargs[key]) 
 212                  del kwargs[key] 
 213          # Were any unrecognized kwargs passed in? 
 214          if __debug__: 
 215              self._complainaboutunusedargs(WRingtoneIndexEntry,kwargs) 
 216          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 217          # Make all P fields that haven't already been constructed 
 218          try: self.__field_name 
 219          except: 
 220              self.__field_name=STRING() 
 221   
 222   
 223 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 224          'Writes this packet to the supplied buffer' 
 225          self._bufferstartoffset=buf.getcurrentoffset() 
 226          try: self.__field_path_prefix 
 227          except: 
 228              self.__field_path_prefix=STRING(**{ 'terminator': None,               'default': '/ff/' }) 
 229          self.__field_path_prefix.writetobuffer(buf) 
 230          self.__field_pathname.writetobuffer(buf) 
 231          try: self.__field_eor 
 232          except: 
 233              self.__field_eor=STRING(**{ 'terminator': None,               'default': '|2\x0A' }) 
 234          self.__field_eor.writetobuffer(buf) 
 235          self._bufferendoffset=buf.getcurrentoffset() 
 236          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 237   
 238   
 239 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 240          'Reads this packet from the supplied buffer' 
 241          self._bufferstartoffset=buf.getcurrentoffset() 
 242          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 243          self.__field_path_prefix=STRING(**{ 'terminator': None,               'default': '/ff/' }) 
 244          self.__field_path_prefix.readfrombuffer(buf) 
 245          self.__field_pathname=STRING(**{ 'terminator': None }) 
 246          self.__field_pathname.readfrombuffer(buf) 
 247          self.__field_eor=STRING(**{ 'terminator': None,               'default': '|2\x0A' }) 
 248          self.__field_eor.readfrombuffer(buf) 
 249          self._bufferendoffset=buf.getcurrentoffset() 
 250   
 251   
 252 -    def __getfield_name(self): 
 253          return self.__field_name.getvalue() 
 254   
 255 -    def __setfield_name(self, value): 
 256          if isinstance(value,STRING): 
 257              self.__field_name=value 
 258          else: 
 259              self.__field_name=STRING(value,) 
 260   
 261 -    def __delfield_name(self): del self.__field_name 
 262   
 263      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
 264   
 265 -    def __getfield_path_prefix(self): 
 266          try: self.__field_path_prefix 
 267          except: 
 268              self.__field_path_prefix=STRING(**{ 'terminator': None,               'default': '/ff/' }) 
 269          return self.__field_path_prefix.getvalue() 
 270   
 271 -    def __setfield_path_prefix(self, value): 
 272          if isinstance(value,STRING): 
 273              self.__field_path_prefix=value 
 274          else: 
 275              self.__field_path_prefix=STRING(value,**{ 'terminator': None,               'default': '/ff/' }) 
 276   
 277 -    def __delfield_path_prefix(self): del self.__field_path_prefix 
 278   
 279      path_prefix=property(__getfield_path_prefix, __setfield_path_prefix, __delfield_path_prefix, None) 
 280   
 281 -    def __getfield_pathname(self): 
 282          return self.__field_pathname.getvalue() 
 283   
 284 -    def __setfield_pathname(self, value): 
 285          if isinstance(value,STRING): 
 286              self.__field_pathname=value 
 287          else: 
 288              self.__field_pathname=STRING(value,**{ 'terminator': None }) 
 289   
 290 -    def __delfield_pathname(self): del self.__field_pathname 
 291   
 292      pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None) 
 293   
 294 -    def __getfield_eor(self): 
 295          try: self.__field_eor 
 296          except: 
 297              self.__field_eor=STRING(**{ 'terminator': None,               'default': '|2\x0A' }) 
 298          return self.__field_eor.getvalue() 
 299   
 300 -    def __setfield_eor(self, value): 
 301          if isinstance(value,STRING): 
 302              self.__field_eor=value 
 303          else: 
 304              self.__field_eor=STRING(value,**{ 'terminator': None,               'default': '|2\x0A' }) 
 305   
 306 -    def __delfield_eor(self): del self.__field_eor 
 307   
 308      eor=property(__getfield_eor, __setfield_eor, __delfield_eor, None) 
 309   
 310 -    def iscontainer(self): 
 311          return True 
 312   
 313 -    def containerelements(self): 
 314          yield ('name', self.__field_name, None) 
 315          yield ('path_prefix', self.__field_path_prefix, None) 
 316          yield ('pathname', self.__field_pathname, None) 
 317          yield ('eor', self.__field_eor, None) 
 318   
 319   
 320   
 321   
 322 -class WRingtoneIndexFile(BaseProtogenClass): 
 323      __fields=['items'] 
 324   
 325 -    def __init__(self, *args, **kwargs): 
 326          dict={} 
 327          # What was supplied to this function 
 328          dict.update(kwargs) 
 329          # Parent constructor 
 330          super(WRingtoneIndexFile,self).__init__(**dict) 
 331          if self.__class__ is WRingtoneIndexFile: 
 332              self._update(args,dict) 
 333   
 334   
 335 -    def getfields(self): 
 336          return self.__fields 
 337   
 338   
 339 -    def _update(self, args, kwargs): 
 340          super(WRingtoneIndexFile,self)._update(args,kwargs) 
 341          keys=kwargs.keys() 
 342          for key in keys: 
 343              if key in self.__fields: 
 344                  setattr(self, key, kwargs[key]) 
 345                  del kwargs[key] 
 346          # Were any unrecognized kwargs passed in? 
 347          if __debug__: 
 348              self._complainaboutunusedargs(WRingtoneIndexFile,kwargs) 
 349          if len(args): 
 350              dict2={ 'elementclass': WRingtoneIndexEntry } 
 351              dict2.update(kwargs) 
 352              kwargs=dict2 
 353              self.__field_items=LIST(*args,**dict2) 
 354          # Make all P fields that haven't already been constructed 
 355   
 356   
 357 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 358          'Writes this packet to the supplied buffer' 
 359          self._bufferstartoffset=buf.getcurrentoffset() 
 360          try: self.__field_items 
 361          except: 
 362              self.__field_items=LIST(**{ 'elementclass': WRingtoneIndexEntry }) 
 363          self.__field_items.writetobuffer(buf) 
 364          self._bufferendoffset=buf.getcurrentoffset() 
 365          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 366   
 367   
 368 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 369          'Reads this packet from the supplied buffer' 
 370          self._bufferstartoffset=buf.getcurrentoffset() 
 371          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 372          self.__field_items=LIST(**{ 'elementclass': WRingtoneIndexEntry }) 
 373          self.__field_items.readfrombuffer(buf) 
 374          self._bufferendoffset=buf.getcurrentoffset() 
 375   
 376   
 377 -    def __getfield_items(self): 
 378          try: self.__field_items 
 379          except: 
 380              self.__field_items=LIST(**{ 'elementclass': WRingtoneIndexEntry }) 
 381          return self.__field_items.getvalue() 
 382   
 383 -    def __setfield_items(self, value): 
 384          if isinstance(value,LIST): 
 385              self.__field_items=value 
 386          else: 
 387              self.__field_items=LIST(value,**{ 'elementclass': WRingtoneIndexEntry }) 
 388   
 389 -    def __delfield_items(self): del self.__field_items 
 390   
 391      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
 392   
 393 -    def iscontainer(self): 
 394          return True 
 395   
 396 -    def containerelements(self): 
 397          yield ('items', self.__field_items, None) 
 398   
 399   
 400   
 401   
 402 -class RRingtoneIndexEntry(BaseProtogenClass): 
 403      __fields=['pathname', 'misc'] 
 404   
 405 -    def __init__(self, *args, **kwargs): 
 406          dict={} 
 407          # What was supplied to this function 
 408          dict.update(kwargs) 
 409          # Parent constructor 
 410          super(RRingtoneIndexEntry,self).__init__(**dict) 
 411          if self.__class__ is RRingtoneIndexEntry: 
 412              self._update(args,dict) 
 413   
 414   
 415 -    def getfields(self): 
 416          return self.__fields 
 417   
 418   
 419 -    def _update(self, args, kwargs): 
 420          super(RRingtoneIndexEntry,self)._update(args,kwargs) 
 421          keys=kwargs.keys() 
 422          for key in keys: 
 423              if key in self.__fields: 
 424                  setattr(self, key, kwargs[key]) 
 425                  del kwargs[key] 
 426          # Were any unrecognized kwargs passed in? 
 427          if __debug__: 
 428              self._complainaboutunusedargs(RRingtoneIndexEntry,kwargs) 
 429          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 430          # Make all P fields that haven't already been constructed 
 431   
 432   
 433 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 434          'Writes this packet to the supplied buffer' 
 435          self._bufferstartoffset=buf.getcurrentoffset() 
 436          self.__field_pathname.writetobuffer(buf) 
 437          self.__field_misc.writetobuffer(buf) 
 438          self._bufferendoffset=buf.getcurrentoffset() 
 439          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 440   
 441   
 442 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 443          'Reads this packet from the supplied buffer' 
 444          self._bufferstartoffset=buf.getcurrentoffset() 
 445          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 446          self.__field_pathname=STRING(**{ 'terminator': 0x7C }) 
 447          self.__field_pathname.readfrombuffer(buf) 
 448          self.__field_misc=STRING(**{ 'terminator': 0x0A }) 
 449          self.__field_misc.readfrombuffer(buf) 
 450          self._bufferendoffset=buf.getcurrentoffset() 
 451   
 452   
 453 -    def __getfield_pathname(self): 
 454          return self.__field_pathname.getvalue() 
 455   
 456 -    def __setfield_pathname(self, value): 
 457          if isinstance(value,STRING): 
 458              self.__field_pathname=value 
 459          else: 
 460              self.__field_pathname=STRING(value,**{ 'terminator': 0x7C }) 
 461   
 462 -    def __delfield_pathname(self): del self.__field_pathname 
 463   
 464      pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None) 
 465   
 466 -    def __getfield_misc(self): 
 467          return self.__field_misc.getvalue() 
 468   
 469 -    def __setfield_misc(self, value): 
 470          if isinstance(value,STRING): 
 471              self.__field_misc=value 
 472          else: 
 473              self.__field_misc=STRING(value,**{ 'terminator': 0x0A }) 
 474   
 475 -    def __delfield_misc(self): del self.__field_misc 
 476   
 477      misc=property(__getfield_misc, __setfield_misc, __delfield_misc, None) 
 478   
 479 -    def iscontainer(self): 
 480          return True 
 481   
 482 -    def containerelements(self): 
 483          yield ('pathname', self.__field_pathname, None) 
 484          yield ('misc', self.__field_misc, None) 
 485   
 486   
 487   
 488   
 489 -class RRingtoneIndexFile(BaseProtogenClass): 
 490      __fields=['items'] 
 491   
 492 -    def __init__(self, *args, **kwargs): 
 493          dict={} 
 494          # What was supplied to this function 
 495          dict.update(kwargs) 
 496          # Parent constructor 
 497          super(RRingtoneIndexFile,self).__init__(**dict) 
 498          if self.__class__ is RRingtoneIndexFile: 
 499              self._update(args,dict) 
 500   
 501   
 502 -    def getfields(self): 
 503          return self.__fields 
 504   
 505   
 506 -    def _update(self, args, kwargs): 
 507          super(RRingtoneIndexFile,self)._update(args,kwargs) 
 508          keys=kwargs.keys() 
 509          for key in keys: 
 510              if key in self.__fields: 
 511                  setattr(self, key, kwargs[key]) 
 512                  del kwargs[key] 
 513          # Were any unrecognized kwargs passed in? 
 514          if __debug__: 
 515              self._complainaboutunusedargs(RRingtoneIndexFile,kwargs) 
 516          if len(args): 
 517              dict2={ 'elementclass': RRingtoneIndexEntry } 
 518              dict2.update(kwargs) 
 519              kwargs=dict2 
 520              self.__field_items=LIST(*args,**dict2) 
 521          # Make all P fields that haven't already been constructed 
 522   
 523   
 524 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 525          'Writes this packet to the supplied buffer' 
 526          self._bufferstartoffset=buf.getcurrentoffset() 
 527          try: self.__field_items 
 528          except: 
 529              self.__field_items=LIST(**{ 'elementclass': RRingtoneIndexEntry }) 
 530          self.__field_items.writetobuffer(buf) 
 531          self._bufferendoffset=buf.getcurrentoffset() 
 532          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 533   
 534   
 535 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 536          'Reads this packet from the supplied buffer' 
 537          self._bufferstartoffset=buf.getcurrentoffset() 
 538          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 539          self.__field_items=LIST(**{ 'elementclass': RRingtoneIndexEntry }) 
 540          self.__field_items.readfrombuffer(buf) 
 541          self._bufferendoffset=buf.getcurrentoffset() 
 542   
 543   
 544 -    def __getfield_items(self): 
 545          try: self.__field_items 
 546          except: 
 547              self.__field_items=LIST(**{ 'elementclass': RRingtoneIndexEntry }) 
 548          return self.__field_items.getvalue() 
 549   
 550 -    def __setfield_items(self, value): 
 551          if isinstance(value,LIST): 
 552              self.__field_items=value 
 553          else: 
 554              self.__field_items=LIST(value,**{ 'elementclass': RRingtoneIndexEntry }) 
 555   
 556 -    def __delfield_items(self): del self.__field_items 
 557   
 558      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
 559   
 560 -    def iscontainer(self): 
 561          return True 
 562   
 563 -    def containerelements(self): 
 564          yield ('items', self.__field_items, None) 
 565   
 566   
 567   
 568   
 569 -class WSoundsIndexEntry(BaseProtogenClass): 
 570      __fields=['name', 'path_prefix', 'pathname', 'eor'] 
 571   
 572 -    def __init__(self, *args, **kwargs): 
 573          dict={} 
 574          # What was supplied to this function 
 575          dict.update(kwargs) 
 576          # Parent constructor 
 577          super(WSoundsIndexEntry,self).__init__(**dict) 
 578          if self.__class__ is WSoundsIndexEntry: 
 579              self._update(args,dict) 
 580   
 581   
 582 -    def getfields(self): 
 583          return self.__fields 
 584   
 585   
 586 -    def _update(self, args, kwargs): 
 587          super(WSoundsIndexEntry,self)._update(args,kwargs) 
 588          keys=kwargs.keys() 
 589          for key in keys: 
 590              if key in self.__fields: 
 591                  setattr(self, key, kwargs[key]) 
 592                  del kwargs[key] 
 593          # Were any unrecognized kwargs passed in? 
 594          if __debug__: 
 595              self._complainaboutunusedargs(WSoundsIndexEntry,kwargs) 
 596          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 597          # Make all P fields that haven't already been constructed 
 598          try: self.__field_name 
 599          except: 
 600              self.__field_name=STRING() 
 601   
 602   
 603 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 604          'Writes this packet to the supplied buffer' 
 605          self._bufferstartoffset=buf.getcurrentoffset() 
 606          try: self.__field_path_prefix 
 607          except: 
 608              self.__field_path_prefix=STRING(**{ 'terminator': None,               'default': '/ff/' }) 
 609          self.__field_path_prefix.writetobuffer(buf) 
 610          self.__field_pathname.writetobuffer(buf) 
 611          try: self.__field_eor 
 612          except: 
 613              self.__field_eor=STRING(**{ 'terminator': None,               'default': '|0|7\x0A' }) 
 614          self.__field_eor.writetobuffer(buf) 
 615          self._bufferendoffset=buf.getcurrentoffset() 
 616          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 617   
 618   
 619 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 620          'Reads this packet from the supplied buffer' 
 621          self._bufferstartoffset=buf.getcurrentoffset() 
 622          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 623          self.__field_path_prefix=STRING(**{ 'terminator': None,               'default': '/ff/' }) 
 624          self.__field_path_prefix.readfrombuffer(buf) 
 625          self.__field_pathname=STRING(**{ 'terminator': None }) 
 626          self.__field_pathname.readfrombuffer(buf) 
 627          self.__field_eor=STRING(**{ 'terminator': None,               'default': '|0|7\x0A' }) 
 628          self.__field_eor.readfrombuffer(buf) 
 629          self._bufferendoffset=buf.getcurrentoffset() 
 630   
 631   
 632 -    def __getfield_name(self): 
 633          return self.__field_name.getvalue() 
 634   
 635 -    def __setfield_name(self, value): 
 636          if isinstance(value,STRING): 
 637              self.__field_name=value 
 638          else: 
 639              self.__field_name=STRING(value,) 
 640   
 641 -    def __delfield_name(self): del self.__field_name 
 642   
 643      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
 644   
 645 -    def __getfield_path_prefix(self): 
 646          try: self.__field_path_prefix 
 647          except: 
 648              self.__field_path_prefix=STRING(**{ 'terminator': None,               'default': '/ff/' }) 
 649          return self.__field_path_prefix.getvalue() 
 650   
 651 -    def __setfield_path_prefix(self, value): 
 652          if isinstance(value,STRING): 
 653              self.__field_path_prefix=value 
 654          else: 
 655              self.__field_path_prefix=STRING(value,**{ 'terminator': None,               'default': '/ff/' }) 
 656   
 657 -    def __delfield_path_prefix(self): del self.__field_path_prefix 
 658   
 659      path_prefix=property(__getfield_path_prefix, __setfield_path_prefix, __delfield_path_prefix, None) 
 660   
 661 -    def __getfield_pathname(self): 
 662          return self.__field_pathname.getvalue() 
 663   
 664 -    def __setfield_pathname(self, value): 
 665          if isinstance(value,STRING): 
 666              self.__field_pathname=value 
 667          else: 
 668              self.__field_pathname=STRING(value,**{ 'terminator': None }) 
 669   
 670 -    def __delfield_pathname(self): del self.__field_pathname 
 671   
 672      pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None) 
 673   
 674 -    def __getfield_eor(self): 
 675          try: self.__field_eor 
 676          except: 
 677              self.__field_eor=STRING(**{ 'terminator': None,               'default': '|0|7\x0A' }) 
 678          return self.__field_eor.getvalue() 
 679   
 680 -    def __setfield_eor(self, value): 
 681          if isinstance(value,STRING): 
 682              self.__field_eor=value 
 683          else: 
 684              self.__field_eor=STRING(value,**{ 'terminator': None,               'default': '|0|7\x0A' }) 
 685   
 686 -    def __delfield_eor(self): del self.__field_eor 
 687   
 688      eor=property(__getfield_eor, __setfield_eor, __delfield_eor, None) 
 689   
 690 -    def iscontainer(self): 
 691          return True 
 692   
 693 -    def containerelements(self): 
 694          yield ('name', self.__field_name, None) 
 695          yield ('path_prefix', self.__field_path_prefix, None) 
 696          yield ('pathname', self.__field_pathname, None) 
 697          yield ('eor', self.__field_eor, None) 
 698   
 699   
 700   
 701   
 702 -class WSoundsIndexFile(BaseProtogenClass): 
 703      __fields=['items'] 
 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(WSoundsIndexFile,self).__init__(**dict) 
 711          if self.__class__ is WSoundsIndexFile: 
 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(WSoundsIndexFile,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(WSoundsIndexFile,kwargs) 
 729          if len(args): 
 730              dict2={ 'elementclass': WSoundsIndexEntry } 
 731              dict2.update(kwargs) 
 732              kwargs=dict2 
 733              self.__field_items=LIST(*args,**dict2) 
 734          # Make all P fields that haven't already been constructed 
 735   
 736   
 737 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 738          'Writes this packet to the supplied buffer' 
 739          self._bufferstartoffset=buf.getcurrentoffset() 
 740          try: self.__field_items 
 741          except: 
 742              self.__field_items=LIST(**{ 'elementclass': WSoundsIndexEntry }) 
 743          self.__field_items.writetobuffer(buf) 
 744          self._bufferendoffset=buf.getcurrentoffset() 
 745          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 746   
 747   
 748 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 749          'Reads this packet from the supplied buffer' 
 750          self._bufferstartoffset=buf.getcurrentoffset() 
 751          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 752          self.__field_items=LIST(**{ 'elementclass': WSoundsIndexEntry }) 
 753          self.__field_items.readfrombuffer(buf) 
 754          self._bufferendoffset=buf.getcurrentoffset() 
 755   
 756   
 757 -    def __getfield_items(self): 
 758          try: self.__field_items 
 759          except: 
 760              self.__field_items=LIST(**{ 'elementclass': WSoundsIndexEntry }) 
 761          return self.__field_items.getvalue() 
 762   
 763 -    def __setfield_items(self, value): 
 764          if isinstance(value,LIST): 
 765              self.__field_items=value 
 766          else: 
 767              self.__field_items=LIST(value,**{ 'elementclass': WSoundsIndexEntry }) 
 768   
 769 -    def __delfield_items(self): del self.__field_items 
 770   
 771      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
 772   
 773 -    def iscontainer(self): 
 774          return True 
 775   
 776 -    def containerelements(self): 
 777          yield ('items', self.__field_items, None) 
 778   
 779   
 780   
 781   
 782 -class RSoundIndexEntry(BaseProtogenClass): 
 783      __fields=['pathname', 'misc'] 
 784   
 785 -    def __init__(self, *args, **kwargs): 
 786          dict={} 
 787          # What was supplied to this function 
 788          dict.update(kwargs) 
 789          # Parent constructor 
 790          super(RSoundIndexEntry,self).__init__(**dict) 
 791          if self.__class__ is RSoundIndexEntry: 
 792              self._update(args,dict) 
 793   
 794   
 795 -    def getfields(self): 
 796          return self.__fields 
 797   
 798   
 799 -    def _update(self, args, kwargs): 
 800          super(RSoundIndexEntry,self)._update(args,kwargs) 
 801          keys=kwargs.keys() 
 802          for key in keys: 
 803              if key in self.__fields: 
 804                  setattr(self, key, kwargs[key]) 
 805                  del kwargs[key] 
 806          # Were any unrecognized kwargs passed in? 
 807          if __debug__: 
 808              self._complainaboutunusedargs(RSoundIndexEntry,kwargs) 
 809          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 810          # Make all P fields that haven't already been constructed 
 811   
 812   
 813 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 814          'Writes this packet to the supplied buffer' 
 815          self._bufferstartoffset=buf.getcurrentoffset() 
 816          self.__field_pathname.writetobuffer(buf) 
 817          self.__field_misc.writetobuffer(buf) 
 818          self._bufferendoffset=buf.getcurrentoffset() 
 819          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 820   
 821   
 822 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 823          'Reads this packet from the supplied buffer' 
 824          self._bufferstartoffset=buf.getcurrentoffset() 
 825          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 826          self.__field_pathname=STRING(**{ 'terminator': 0x7C }) 
 827          self.__field_pathname.readfrombuffer(buf) 
 828          self.__field_misc=STRING(**{ 'terminator': 0x0A }) 
 829          self.__field_misc.readfrombuffer(buf) 
 830          self._bufferendoffset=buf.getcurrentoffset() 
 831   
 832   
 833 -    def __getfield_pathname(self): 
 834          return self.__field_pathname.getvalue() 
 835   
 836 -    def __setfield_pathname(self, value): 
 837          if isinstance(value,STRING): 
 838              self.__field_pathname=value 
 839          else: 
 840              self.__field_pathname=STRING(value,**{ 'terminator': 0x7C }) 
 841   
 842 -    def __delfield_pathname(self): del self.__field_pathname 
 843   
 844      pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None) 
 845   
 846 -    def __getfield_misc(self): 
 847          return self.__field_misc.getvalue() 
 848   
 849 -    def __setfield_misc(self, value): 
 850          if isinstance(value,STRING): 
 851              self.__field_misc=value 
 852          else: 
 853              self.__field_misc=STRING(value,**{ 'terminator': 0x0A }) 
 854   
 855 -    def __delfield_misc(self): del self.__field_misc 
 856   
 857      misc=property(__getfield_misc, __setfield_misc, __delfield_misc, None) 
 858   
 859 -    def iscontainer(self): 
 860          return True 
 861   
 862 -    def containerelements(self): 
 863          yield ('pathname', self.__field_pathname, None) 
 864          yield ('misc', self.__field_misc, None) 
 865   
 866   
 867   
 868   
 869 -class RSoundsIndexFile(BaseProtogenClass): 
 870      __fields=['items'] 
 871   
 872 -    def __init__(self, *args, **kwargs): 
 873          dict={} 
 874          # What was supplied to this function 
 875          dict.update(kwargs) 
 876          # Parent constructor 
 877          super(RSoundsIndexFile,self).__init__(**dict) 
 878          if self.__class__ is RSoundsIndexFile: 
 879              self._update(args,dict) 
 880   
 881   
 882 -    def getfields(self): 
 883          return self.__fields 
 884   
 885   
 886 -    def _update(self, args, kwargs): 
 887          super(RSoundsIndexFile,self)._update(args,kwargs) 
 888          keys=kwargs.keys() 
 889          for key in keys: 
 890              if key in self.__fields: 
 891                  setattr(self, key, kwargs[key]) 
 892                  del kwargs[key] 
 893          # Were any unrecognized kwargs passed in? 
 894          if __debug__: 
 895              self._complainaboutunusedargs(RSoundsIndexFile,kwargs) 
 896          if len(args): 
 897              dict2={ 'elementclass': RSoundIndexEntry } 
 898              dict2.update(kwargs) 
 899              kwargs=dict2 
 900              self.__field_items=LIST(*args,**dict2) 
 901          # Make all P fields that haven't already been constructed 
 902   
 903   
 904 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 905          'Writes this packet to the supplied buffer' 
 906          self._bufferstartoffset=buf.getcurrentoffset() 
 907          try: self.__field_items 
 908          except: 
 909              self.__field_items=LIST(**{ 'elementclass': RSoundIndexEntry }) 
 910          self.__field_items.writetobuffer(buf) 
 911          self._bufferendoffset=buf.getcurrentoffset() 
 912          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 913   
 914   
 915 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 916          'Reads this packet from the supplied buffer' 
 917          self._bufferstartoffset=buf.getcurrentoffset() 
 918          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 919          self.__field_items=LIST(**{ 'elementclass': RSoundIndexEntry }) 
 920          self.__field_items.readfrombuffer(buf) 
 921          self._bufferendoffset=buf.getcurrentoffset() 
 922   
 923   
 924 -    def __getfield_items(self): 
 925          try: self.__field_items 
 926          except: 
 927              self.__field_items=LIST(**{ 'elementclass': RSoundIndexEntry }) 
 928          return self.__field_items.getvalue() 
 929   
 930 -    def __setfield_items(self, value): 
 931          if isinstance(value,LIST): 
 932              self.__field_items=value 
 933          else: 
 934              self.__field_items=LIST(value,**{ 'elementclass': RSoundIndexEntry }) 
 935   
 936 -    def __delfield_items(self): del self.__field_items 
 937   
 938      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
 939   
 940 -    def iscontainer(self): 
 941          return True 
 942   
 943 -    def containerelements(self): 
 944          yield ('items', self.__field_items, None) 
 945   
 946   
 947   
 948   
 949 -class WPictureIndexEntry(BaseProtogenClass): 
 950      __fields=['name', 'path_prefix', 'pathname', 'eor'] 
 951   
 952 -    def __init__(self, *args, **kwargs): 
 953          dict={} 
 954          # What was supplied to this function 
 955          dict.update(kwargs) 
 956          # Parent constructor 
 957          super(WPictureIndexEntry,self).__init__(**dict) 
 958          if self.__class__ is WPictureIndexEntry: 
 959              self._update(args,dict) 
 960   
 961   
 962 -    def getfields(self): 
 963          return self.__fields 
 964   
 965   
 966 -    def _update(self, args, kwargs): 
 967          super(WPictureIndexEntry,self)._update(args,kwargs) 
 968          keys=kwargs.keys() 
 969          for key in keys: 
 970              if key in self.__fields: 
 971                  setattr(self, key, kwargs[key]) 
 972                  del kwargs[key] 
 973          # Were any unrecognized kwargs passed in? 
 974          if __debug__: 
 975              self._complainaboutunusedargs(WPictureIndexEntry,kwargs) 
 976          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 977          # Make all P fields that haven't already been constructed 
 978   
 979   
 980 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 981          'Writes this packet to the supplied buffer' 
 982          self._bufferstartoffset=buf.getcurrentoffset() 
 983          self.__field_name.writetobuffer(buf) 
 984          try: self.__field_path_prefix 
 985          except: 
 986              self.__field_path_prefix=STRING(**{ 'terminator': None,               'default': '|/ff/' }) 
 987          self.__field_path_prefix.writetobuffer(buf) 
 988          self.__field_pathname.writetobuffer(buf) 
 989          try: self.__field_eor 
 990          except: 
 991              self.__field_eor=STRING(**{ 'terminator': None,               'default': '|0|0|3|>\x0A\xF4' }) 
 992          self.__field_eor.writetobuffer(buf) 
 993          self._bufferendoffset=buf.getcurrentoffset() 
 994          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 995   
 996   
 997 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 998          'Reads this packet from the supplied buffer' 
 999          self._bufferstartoffset=buf.getcurrentoffset() 
1000          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1001          self.__field_name=STRING(**{ 'terminator': None }) 
1002          self.__field_name.readfrombuffer(buf) 
1003          self.__field_path_prefix=STRING(**{ 'terminator': None,               'default': '|/ff/' }) 
1004          self.__field_path_prefix.readfrombuffer(buf) 
1005          self.__field_pathname=STRING(**{ 'terminator': None }) 
1006          self.__field_pathname.readfrombuffer(buf) 
1007          self.__field_eor=STRING(**{ 'terminator': None,               'default': '|0|0|3|>\x0A\xF4' }) 
1008          self.__field_eor.readfrombuffer(buf) 
1009          self._bufferendoffset=buf.getcurrentoffset() 
1010   
1011   
1012 -    def __getfield_name(self): 
1013          return self.__field_name.getvalue() 
1014   
1015 -    def __setfield_name(self, value): 
1016          if isinstance(value,STRING): 
1017              self.__field_name=value 
1018          else: 
1019              self.__field_name=STRING(value,**{ 'terminator': None }) 
1020   
1021 -    def __delfield_name(self): del self.__field_name 
1022   
1023      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
1024   
1025 -    def __getfield_path_prefix(self): 
1026          try: self.__field_path_prefix 
1027          except: 
1028              self.__field_path_prefix=STRING(**{ 'terminator': None,               'default': '|/ff/' }) 
1029          return self.__field_path_prefix.getvalue() 
1030   
1031 -    def __setfield_path_prefix(self, value): 
1032          if isinstance(value,STRING): 
1033              self.__field_path_prefix=value 
1034          else: 
1035              self.__field_path_prefix=STRING(value,**{ 'terminator': None,               'default': '|/ff/' }) 
1036   
1037 -    def __delfield_path_prefix(self): del self.__field_path_prefix 
1038   
1039      path_prefix=property(__getfield_path_prefix, __setfield_path_prefix, __delfield_path_prefix, None) 
1040   
1041 -    def __getfield_pathname(self): 
1042          return self.__field_pathname.getvalue() 
1043   
1044 -    def __setfield_pathname(self, value): 
1045          if isinstance(value,STRING): 
1046              self.__field_pathname=value 
1047          else: 
1048              self.__field_pathname=STRING(value,**{ 'terminator': None }) 
1049   
1050 -    def __delfield_pathname(self): del self.__field_pathname 
1051   
1052      pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None) 
1053   
1054 -    def __getfield_eor(self): 
1055          try: self.__field_eor 
1056          except: 
1057              self.__field_eor=STRING(**{ 'terminator': None,               'default': '|0|0|3|>\x0A\xF4' }) 
1058          return self.__field_eor.getvalue() 
1059   
1060 -    def __setfield_eor(self, value): 
1061          if isinstance(value,STRING): 
1062              self.__field_eor=value 
1063          else: 
1064              self.__field_eor=STRING(value,**{ 'terminator': None,               'default': '|0|0|3|>\x0A\xF4' }) 
1065   
1066 -    def __delfield_eor(self): del self.__field_eor 
1067   
1068      eor=property(__getfield_eor, __setfield_eor, __delfield_eor, None) 
1069   
1070 -    def iscontainer(self): 
1071          return True 
1072   
1073 -    def containerelements(self): 
1074          yield ('name', self.__field_name, None) 
1075          yield ('path_prefix', self.__field_path_prefix, None) 
1076          yield ('pathname', self.__field_pathname, None) 
1077          yield ('eor', self.__field_eor, None) 
1078   
1079   
1080   
1081   
1082 -class WPictureIndexFile(BaseProtogenClass): 
1083      __fields=['header', 'items'] 
1084   
1085 -    def __init__(self, *args, **kwargs): 
1086          dict={} 
1087          # What was supplied to this function 
1088          dict.update(kwargs) 
1089          # Parent constructor 
1090          super(WPictureIndexFile,self).__init__(**dict) 
1091          if self.__class__ is WPictureIndexFile: 
1092              self._update(args,dict) 
1093   
1094   
1095 -    def getfields(self): 
1096          return self.__fields 
1097   
1098   
1099 -    def _update(self, args, kwargs): 
1100          super(WPictureIndexFile,self)._update(args,kwargs) 
1101          keys=kwargs.keys() 
1102          for key in keys: 
1103              if key in self.__fields: 
1104                  setattr(self, key, kwargs[key]) 
1105                  del kwargs[key] 
1106          # Were any unrecognized kwargs passed in? 
1107          if __debug__: 
1108              self._complainaboutunusedargs(WPictureIndexFile,kwargs) 
1109          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1110          # Make all P fields that haven't already been constructed 
1111   
1112   
1113 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1114          'Writes this packet to the supplied buffer' 
1115          self._bufferstartoffset=buf.getcurrentoffset() 
1116          try: self.__field_header 
1117          except: 
1118              self.__field_header=STRING(**{ 'terminator': None,               'default': '0|/ff/brew/16452/mp/Default Album|\x0A\x0A\xF4' }) 
1119          self.__field_header.writetobuffer(buf) 
1120          try: self.__field_items 
1121          except: 
1122              self.__field_items=LIST(**{ 'elementclass': WPictureIndexEntry }) 
1123          self.__field_items.writetobuffer(buf) 
1124          self._bufferendoffset=buf.getcurrentoffset() 
1125          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1126   
1127   
1128 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1129          'Reads this packet from the supplied buffer' 
1130          self._bufferstartoffset=buf.getcurrentoffset() 
1131          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1132          self.__field_header=STRING(**{ 'terminator': None,               'default': '0|/ff/brew/16452/mp/Default Album|\x0A\x0A\xF4' }) 
1133          self.__field_header.readfrombuffer(buf) 
1134          self.__field_items=LIST(**{ 'elementclass': WPictureIndexEntry }) 
1135          self.__field_items.readfrombuffer(buf) 
1136          self._bufferendoffset=buf.getcurrentoffset() 
1137   
1138   
1139 -    def __getfield_header(self): 
1140          try: self.__field_header 
1141          except: 
1142              self.__field_header=STRING(**{ 'terminator': None,               'default': '0|/ff/brew/16452/mp/Default Album|\x0A\x0A\xF4' }) 
1143          return self.__field_header.getvalue() 
1144   
1145 -    def __setfield_header(self, value): 
1146          if isinstance(value,STRING): 
1147              self.__field_header=value 
1148          else: 
1149              self.__field_header=STRING(value,**{ 'terminator': None,               'default': '0|/ff/brew/16452/mp/Default Album|\x0A\x0A\xF4' }) 
1150   
1151 -    def __delfield_header(self): del self.__field_header 
1152   
1153      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
1154   
1155 -    def __getfield_items(self): 
1156          try: self.__field_items 
1157          except: 
1158              self.__field_items=LIST(**{ 'elementclass': WPictureIndexEntry }) 
1159          return self.__field_items.getvalue() 
1160   
1161 -    def __setfield_items(self, value): 
1162          if isinstance(value,LIST): 
1163              self.__field_items=value 
1164          else: 
1165              self.__field_items=LIST(value,**{ 'elementclass': WPictureIndexEntry }) 
1166   
1167 -    def __delfield_items(self): del self.__field_items 
1168   
1169      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
1170   
1171 -    def iscontainer(self): 
1172          return True 
1173   
1174 -    def containerelements(self): 
1175          yield ('header', self.__field_header, None) 
1176          yield ('items', self.__field_items, None) 
1177   
1178   
1179   
1180   
1181 -class RPictureIndexEntry(BaseProtogenClass): 
1182      __fields=['name', 'pathname', 'misc'] 
1183   
1184 -    def __init__(self, *args, **kwargs): 
1185          dict={} 
1186          # What was supplied to this function 
1187          dict.update(kwargs) 
1188          # Parent constructor 
1189          super(RPictureIndexEntry,self).__init__(**dict) 
1190          if self.__class__ is RPictureIndexEntry: 
1191              self._update(args,dict) 
1192   
1193   
1194 -    def getfields(self): 
1195          return self.__fields 
1196   
1197   
1198 -    def _update(self, args, kwargs): 
1199          super(RPictureIndexEntry,self)._update(args,kwargs) 
1200          keys=kwargs.keys() 
1201          for key in keys: 
1202              if key in self.__fields: 
1203                  setattr(self, key, kwargs[key]) 
1204                  del kwargs[key] 
1205          # Were any unrecognized kwargs passed in? 
1206          if __debug__: 
1207              self._complainaboutunusedargs(RPictureIndexEntry,kwargs) 
1208          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1209          # Make all P fields that haven't already been constructed 
1210   
1211   
1212 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1213          'Writes this packet to the supplied buffer' 
1214          self._bufferstartoffset=buf.getcurrentoffset() 
1215          self.__field_name.writetobuffer(buf) 
1216          self.__field_pathname.writetobuffer(buf) 
1217          self.__field_misc.writetobuffer(buf) 
1218          self._bufferendoffset=buf.getcurrentoffset() 
1219          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1220   
1221   
1222 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1223          'Reads this packet from the supplied buffer' 
1224          self._bufferstartoffset=buf.getcurrentoffset() 
1225          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1226          self.__field_name=STRING(**{ 'terminator': 0x7C }) 
1227          self.__field_name.readfrombuffer(buf) 
1228          self.__field_pathname=STRING(**{ 'terminator': 0x7C }) 
1229          self.__field_pathname.readfrombuffer(buf) 
1230          self.__field_misc=STRING(**{ 'terminator': 0xF4,               'raiseonunterminatedread': False }) 
1231          self.__field_misc.readfrombuffer(buf) 
1232          self._bufferendoffset=buf.getcurrentoffset() 
1233   
1234   
1235 -    def __getfield_name(self): 
1236          return self.__field_name.getvalue() 
1237   
1238 -    def __setfield_name(self, value): 
1239          if isinstance(value,STRING): 
1240              self.__field_name=value 
1241          else: 
1242              self.__field_name=STRING(value,**{ 'terminator': 0x7C }) 
1243   
1244 -    def __delfield_name(self): del self.__field_name 
1245   
1246      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
1247   
1248 -    def __getfield_pathname(self): 
1249          return self.__field_pathname.getvalue() 
1250   
1251 -    def __setfield_pathname(self, value): 
1252          if isinstance(value,STRING): 
1253              self.__field_pathname=value 
1254          else: 
1255              self.__field_pathname=STRING(value,**{ 'terminator': 0x7C }) 
1256   
1257 -    def __delfield_pathname(self): del self.__field_pathname 
1258   
1259      pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None) 
1260   
1261 -    def __getfield_misc(self): 
1262          return self.__field_misc.getvalue() 
1263   
1264 -    def __setfield_misc(self, value): 
1265          if isinstance(value,STRING): 
1266              self.__field_misc=value 
1267          else: 
1268              self.__field_misc=STRING(value,**{ 'terminator': 0xF4,               'raiseonunterminatedread': False }) 
1269   
1270 -    def __delfield_misc(self): del self.__field_misc 
1271   
1272      misc=property(__getfield_misc, __setfield_misc, __delfield_misc, None) 
1273   
1274 -    def iscontainer(self): 
1275          return True 
1276   
1277 -    def containerelements(self): 
1278          yield ('name', self.__field_name, None) 
1279          yield ('pathname', self.__field_pathname, None) 
1280          yield ('misc', self.__field_misc, None) 
1281   
1282   
1283   
1284   
1285 -class RPictureIndexFile(BaseProtogenClass): 
1286      __fields=['items'] 
1287   
1288 -    def __init__(self, *args, **kwargs): 
1289          dict={} 
1290          # What was supplied to this function 
1291          dict.update(kwargs) 
1292          # Parent constructor 
1293          super(RPictureIndexFile,self).__init__(**dict) 
1294          if self.__class__ is RPictureIndexFile: 
1295              self._update(args,dict) 
1296   
1297   
1298 -    def getfields(self): 
1299          return self.__fields 
1300   
1301   
1302 -    def _update(self, args, kwargs): 
1303          super(RPictureIndexFile,self)._update(args,kwargs) 
1304          keys=kwargs.keys() 
1305          for key in keys: 
1306              if key in self.__fields: 
1307                  setattr(self, key, kwargs[key]) 
1308                  del kwargs[key] 
1309          # Were any unrecognized kwargs passed in? 
1310          if __debug__: 
1311              self._complainaboutunusedargs(RPictureIndexFile,kwargs) 
1312          if len(args): 
1313              dict2={ 'elementclass': RPictureIndexEntry } 
1314              dict2.update(kwargs) 
1315              kwargs=dict2 
1316              self.__field_items=LIST(*args,**dict2) 
1317          # Make all P fields that haven't already been constructed 
1318   
1319   
1320 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1321          'Writes this packet to the supplied buffer' 
1322          self._bufferstartoffset=buf.getcurrentoffset() 
1323          try: self.__field_items 
1324          except: 
1325              self.__field_items=LIST(**{ 'elementclass': RPictureIndexEntry }) 
1326          self.__field_items.writetobuffer(buf) 
1327          self._bufferendoffset=buf.getcurrentoffset() 
1328          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1329   
1330   
1331 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1332          'Reads this packet from the supplied buffer' 
1333          self._bufferstartoffset=buf.getcurrentoffset() 
1334          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1335          self.__field_items=LIST(**{ 'elementclass': RPictureIndexEntry }) 
1336          self.__field_items.readfrombuffer(buf) 
1337          self._bufferendoffset=buf.getcurrentoffset() 
1338   
1339   
1340 -    def __getfield_items(self): 
1341          try: self.__field_items 
1342          except: 
1343              self.__field_items=LIST(**{ 'elementclass': RPictureIndexEntry }) 
1344          return self.__field_items.getvalue() 
1345   
1346 -    def __setfield_items(self, value): 
1347          if isinstance(value,LIST): 
1348              self.__field_items=value 
1349          else: 
1350              self.__field_items=LIST(value,**{ 'elementclass': RPictureIndexEntry }) 
1351   
1352 -    def __delfield_items(self): del self.__field_items 
1353   
1354      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
1355   
1356 -    def iscontainer(self): 
1357          return True 
1358   
1359 -    def containerelements(self): 
1360          yield ('items', self.__field_items, None) 
1361   
1362   
1363   
1364   
1365 -class GroupEntry(BaseProtogenClass): 
1366      # Read-From-Buffer-Only Class 
1367      __fields=['index', 'datetime', 'name', 'numofmembers', 'members'] 
1368   
1369 -    def __init__(self, *args, **kwargs): 
1370          dict={} 
1371          # What was supplied to this function 
1372          dict.update(kwargs) 
1373          # Parent constructor 
1374          super(GroupEntry,self).__init__(**dict) 
1375          if self.__class__ is GroupEntry: 
1376              self._update(args,dict) 
1377   
1378   
1379 -    def getfields(self): 
1380          return self.__fields 
1381   
1382   
1383 -    def _update(self, args, kwargs): 
1384          super(GroupEntry,self)._update(args,kwargs) 
1385          keys=kwargs.keys() 
1386          for key in keys: 
1387              if key in self.__fields: 
1388                  setattr(self, key, kwargs[key]) 
1389                  del kwargs[key] 
1390          # Were any unrecognized kwargs passed in? 
1391          if __debug__: 
1392              self._complainaboutunusedargs(GroupEntry,kwargs) 
1393          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1394          # Make all P fields that haven't already been constructed 
1395   
1396   
1397 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1398          'Writes this packet to the supplied buffer' 
1399          raise NotImplementedError 
1400   
1401   
1402 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1403          'Reads this packet from the supplied buffer' 
1404          self._bufferstartoffset=buf.getcurrentoffset() 
1405          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1406          self.__field_index=UINT(**{'sizeinbytes': 1}) 
1407          self.__field_index.readfrombuffer(buf) 
1408          DONTCARE(**{'sizeinbytes': 4}).readfrombuffer(buf) 
1409          self.__field_datetime=DateTime(**{'sizeinbytes': 4}) 
1410          self.__field_datetime.readfrombuffer(buf) 
1411          self.__field_name=USTRING(**{'sizeinbytes': 68,  'encoding': ENCODING,                 'terminator': 0 }) 
1412          self.__field_name.readfrombuffer(buf) 
1413          self.__field_numofmembers=UINT(**{'sizeinbytes': 2}) 
1414          self.__field_numofmembers.readfrombuffer(buf) 
1415          if self.numofmembers: 
1416              self.__field_members=LIST(**{'elementclass': _gen_p_samsungscha950_188,  'length': self.numofmembers }) 
1417              self.__field_members.readfrombuffer(buf) 
1418          self._bufferendoffset=buf.getcurrentoffset() 
1419   
1420   
1421 -    def __getfield_index(self): 
1422          return self.__field_index.getvalue() 
1423   
1424 -    def __setfield_index(self, value): 
1425          if isinstance(value,UINT): 
1426              self.__field_index=value 
1427          else: 
1428              self.__field_index=UINT(value,**{'sizeinbytes': 1}) 
1429   
1430 -    def __delfield_index(self): del self.__field_index 
1431   
1432      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
1433   
1434 -    def __getfield_datetime(self): 
1435          return self.__field_datetime.getvalue() 
1436   
1437 -    def __setfield_datetime(self, value): 
1438          if isinstance(value,DateTime): 
1439              self.__field_datetime=value 
1440          else: 
1441              self.__field_datetime=DateTime(value,**{'sizeinbytes': 4}) 
1442   
1443 -    def __delfield_datetime(self): del self.__field_datetime 
1444   
1445      datetime=property(__getfield_datetime, __setfield_datetime, __delfield_datetime, None) 
1446   
1447 -    def __getfield_name(self): 
1448          return self.__field_name.getvalue() 
1449   
1450 -    def __setfield_name(self, value): 
1451          if isinstance(value,USTRING): 
1452              self.__field_name=value 
1453          else: 
1454              self.__field_name=USTRING(value,**{'sizeinbytes': 68,  'encoding': ENCODING,                 'terminator': 0 }) 
1455   
1456 -    def __delfield_name(self): del self.__field_name 
1457   
1458      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
1459   
1460 -    def __getfield_numofmembers(self): 
1461          return self.__field_numofmembers.getvalue() 
1462   
1463 -    def __setfield_numofmembers(self, value): 
1464          if isinstance(value,UINT): 
1465              self.__field_numofmembers=value 
1466          else: 
1467              self.__field_numofmembers=UINT(value,**{'sizeinbytes': 2}) 
1468   
1469 -    def __delfield_numofmembers(self): del self.__field_numofmembers 
1470   
1471      numofmembers=property(__getfield_numofmembers, __setfield_numofmembers, __delfield_numofmembers, None) 
1472   
1473 -    def __getfield_members(self): 
1474          return self.__field_members.getvalue() 
1475   
1476 -    def __setfield_members(self, value): 
1477          if isinstance(value,LIST): 
1478              self.__field_members=value 
1479          else: 
1480              self.__field_members=LIST(value,**{'elementclass': _gen_p_samsungscha950_188,  'length': self.numofmembers }) 
1481   
1482 -    def __delfield_members(self): del self.__field_members 
1483   
1484      members=property(__getfield_members, __setfield_members, __delfield_members, None) 
1485   
1486 -    def iscontainer(self): 
1487          return True 
1488   
1489 -    def containerelements(self): 
1490          yield ('index', self.__field_index, None) 
1491          yield ('datetime', self.__field_datetime, None) 
1492          yield ('name', self.__field_name, None) 
1493          yield ('numofmembers', self.__field_numofmembers, None) 
1494          if self.numofmembers: 
1495              yield ('members', self.__field_members, None) 
1496   
1497   
1498   
1499   
1500 -class _gen_p_samsungscha950_188(BaseProtogenClass): 
1501      'Anonymous inner class' 
1502      __fields=['index'] 
1503   
1504 -    def __init__(self, *args, **kwargs): 
1505          dict={} 
1506          # What was supplied to this function 
1507          dict.update(kwargs) 
1508          # Parent constructor 
1509          super(_gen_p_samsungscha950_188,self).__init__(**dict) 
1510          if self.__class__ is _gen_p_samsungscha950_188: 
1511              self._update(args,dict) 
1512   
1513   
1514 -    def getfields(self): 
1515          return self.__fields 
1516   
1517   
1518 -    def _update(self, args, kwargs): 
1519          super(_gen_p_samsungscha950_188,self)._update(args,kwargs) 
1520          keys=kwargs.keys() 
1521          for key in keys: 
1522              if key in self.__fields: 
1523                  setattr(self, key, kwargs[key]) 
1524                  del kwargs[key] 
1525          # Were any unrecognized kwargs passed in? 
1526          if __debug__: 
1527              self._complainaboutunusedargs(_gen_p_samsungscha950_188,kwargs) 
1528          if len(args): 
1529              dict2={'sizeinbytes': 2} 
1530              dict2.update(kwargs) 
1531              kwargs=dict2 
1532              self.__field_index=UINT(*args,**dict2) 
1533          # Make all P fields that haven't already been constructed 
1534   
1535   
1536 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1537          'Writes this packet to the supplied buffer' 
1538          self._bufferstartoffset=buf.getcurrentoffset() 
1539          self.__field_index.writetobuffer(buf) 
1540          self._bufferendoffset=buf.getcurrentoffset() 
1541          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1542   
1543   
1544 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1545          'Reads this packet from the supplied buffer' 
1546          self._bufferstartoffset=buf.getcurrentoffset() 
1547          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1548          self.__field_index=UINT(**{'sizeinbytes': 2}) 
1549          self.__field_index.readfrombuffer(buf) 
1550          self._bufferendoffset=buf.getcurrentoffset() 
1551   
1552   
1553 -    def __getfield_index(self): 
1554          return self.__field_index.getvalue() 
1555   
1556 -    def __setfield_index(self, value): 
1557          if isinstance(value,UINT): 
1558              self.__field_index=value 
1559          else: 
1560              self.__field_index=UINT(value,**{'sizeinbytes': 2}) 
1561   
1562 -    def __delfield_index(self): del self.__field_index 
1563   
1564      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
1565   
1566 -    def iscontainer(self): 
1567          return True 
1568   
1569 -    def containerelements(self): 
1570          yield ('index', self.__field_index, None) 
1571   
1572   
1573   
1574   
1575 -class GroupIndexFile(BaseProtogenClass): 
1576      # Read-From-Buffer-Only Class 
1577      __fields=['num_of_entries', 'items'] 
1578   
1579 -    def __init__(self, *args, **kwargs): 
1580          dict={} 
1581          # What was supplied to this function 
1582          dict.update(kwargs) 
1583          # Parent constructor 
1584          super(GroupIndexFile,self).__init__(**dict) 
1585          if self.__class__ is GroupIndexFile: 
1586              self._update(args,dict) 
1587   
1588   
1589 -    def getfields(self): 
1590          return self.__fields 
1591   
1592   
1593 -    def _update(self, args, kwargs): 
1594          super(GroupIndexFile,self)._update(args,kwargs) 
1595          keys=kwargs.keys() 
1596          for key in keys: 
1597              if key in self.__fields: 
1598                  setattr(self, key, kwargs[key]) 
1599                  del kwargs[key] 
1600          # Were any unrecognized kwargs passed in? 
1601          if __debug__: 
1602              self._complainaboutunusedargs(GroupIndexFile,kwargs) 
1603          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1604          # Make all P fields that haven't already been constructed 
1605   
1606   
1607 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1608          'Writes this packet to the supplied buffer' 
1609          raise NotImplementedError 
1610   
1611   
1612 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1613          'Reads this packet from the supplied buffer' 
1614          self._bufferstartoffset=buf.getcurrentoffset() 
1615          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1616          self.__field_num_of_entries=UINT(**{'sizeinbytes': 1}) 
1617          self.__field_num_of_entries.readfrombuffer(buf) 
1618          self.__field_items=LIST(**{ 'elementclass': GroupEntry }) 
1619          self.__field_items.readfrombuffer(buf) 
1620          self._bufferendoffset=buf.getcurrentoffset() 
1621   
1622   
1623 -    def __getfield_num_of_entries(self): 
1624          return self.__field_num_of_entries.getvalue() 
1625   
1626 -    def __setfield_num_of_entries(self, value): 
1627          if isinstance(value,UINT): 
1628              self.__field_num_of_entries=value 
1629          else: 
1630              self.__field_num_of_entries=UINT(value,**{'sizeinbytes': 1}) 
1631   
1632 -    def __delfield_num_of_entries(self): del self.__field_num_of_entries 
1633   
1634      num_of_entries=property(__getfield_num_of_entries, __setfield_num_of_entries, __delfield_num_of_entries, None) 
1635   
1636 -    def __getfield_items(self): 
1637          try: self.__field_items 
1638          except: 
1639              self.__field_items=LIST(**{ 'elementclass': GroupEntry }) 
1640          return self.__field_items.getvalue() 
1641   
1642 -    def __setfield_items(self, value): 
1643          if isinstance(value,LIST): 
1644              self.__field_items=value 
1645          else: 
1646              self.__field_items=LIST(value,**{ 'elementclass': GroupEntry }) 
1647   
1648 -    def __delfield_items(self): del self.__field_items 
1649   
1650      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
1651   
1652 -    def iscontainer(self): 
1653          return True 
1654   
1655 -    def containerelements(self): 
1656          yield ('num_of_entries', self.__field_num_of_entries, None) 
1657          yield ('items', self.__field_items, None) 
1658   
1659   
1660   
1661   
1662 -class CalIndexEntry(BaseProtogenClass): 
1663      __fields=['index'] 
1664   
1665 -    def __init__(self, *args, **kwargs): 
1666          dict={} 
1667          # What was supplied to this function 
1668          dict.update(kwargs) 
1669          # Parent constructor 
1670          super(CalIndexEntry,self).__init__(**dict) 
1671          if self.__class__ is CalIndexEntry: 
1672              self._update(args,dict) 
1673   
1674   
1675 -    def getfields(self): 
1676          return self.__fields 
1677   
1678   
1679 -    def _update(self, args, kwargs): 
1680          super(CalIndexEntry,self)._update(args,kwargs) 
1681          keys=kwargs.keys() 
1682          for key in keys: 
1683              if key in self.__fields: 
1684                  setattr(self, key, kwargs[key]) 
1685                  del kwargs[key] 
1686          # Were any unrecognized kwargs passed in? 
1687          if __debug__: 
1688              self._complainaboutunusedargs(CalIndexEntry,kwargs) 
1689          if len(args): 
1690              dict2={'sizeinbytes': 2,  'default': 0 } 
1691              dict2.update(kwargs) 
1692              kwargs=dict2 
1693              self.__field_index=UINT(*args,**dict2) 
1694          # Make all P fields that haven't already been constructed 
1695   
1696   
1697 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1698          'Writes this packet to the supplied buffer' 
1699          self._bufferstartoffset=buf.getcurrentoffset() 
1700          try: self.__field_index 
1701          except: 
1702              self.__field_index=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1703          self.__field_index.writetobuffer(buf) 
1704          self._bufferendoffset=buf.getcurrentoffset() 
1705          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1706   
1707   
1708 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1709          'Reads this packet from the supplied buffer' 
1710          self._bufferstartoffset=buf.getcurrentoffset() 
1711          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1712          self.__field_index=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1713          self.__field_index.readfrombuffer(buf) 
1714          self._bufferendoffset=buf.getcurrentoffset() 
1715   
1716   
1717 -    def __getfield_index(self): 
1718          try: self.__field_index 
1719          except: 
1720              self.__field_index=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1721          return self.__field_index.getvalue() 
1722   
1723 -    def __setfield_index(self, value): 
1724          if isinstance(value,UINT): 
1725              self.__field_index=value 
1726          else: 
1727              self.__field_index=UINT(value,**{'sizeinbytes': 2,  'default': 0 }) 
1728   
1729 -    def __delfield_index(self): del self.__field_index 
1730   
1731      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
1732   
1733 -    def iscontainer(self): 
1734          return True 
1735   
1736 -    def containerelements(self): 
1737          yield ('index', self.__field_index, None) 
1738   
1739   
1740   
1741   
1742 -class CalIndexFile(BaseProtogenClass): 
1743      __fields=['next_index', 'zero1', 'numofevents', 'zero2', 'numofnotes', 'zero3', 'numofactiveevents', 'zero4', 'events', 'notes', 'activeevents'] 
1744   
1745 -    def __init__(self, *args, **kwargs): 
1746          dict={} 
1747          # What was supplied to this function 
1748          dict.update(kwargs) 
1749          # Parent constructor 
1750          super(CalIndexFile,self).__init__(**dict) 
1751          if self.__class__ is CalIndexFile: 
1752              self._update(args,dict) 
1753   
1754   
1755 -    def getfields(self): 
1756          return self.__fields 
1757   
1758   
1759 -    def _update(self, args, kwargs): 
1760          super(CalIndexFile,self)._update(args,kwargs) 
1761          keys=kwargs.keys() 
1762          for key in keys: 
1763              if key in self.__fields: 
1764                  setattr(self, key, kwargs[key]) 
1765                  del kwargs[key] 
1766          # Were any unrecognized kwargs passed in? 
1767          if __debug__: 
1768              self._complainaboutunusedargs(CalIndexFile,kwargs) 
1769          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1770          # Make all P fields that haven't already been constructed 
1771   
1772   
1773 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1774          'Writes this packet to the supplied buffer' 
1775          self._bufferstartoffset=buf.getcurrentoffset() 
1776          self.__field_next_index.writetobuffer(buf) 
1777          try: self.__field_zero1 
1778          except: 
1779              self.__field_zero1=UNKNOWN(**{'sizeinbytes': 12,  'pad': 0 }) 
1780          self.__field_zero1.writetobuffer(buf) 
1781          self.__field_numofevents.writetobuffer(buf) 
1782          try: self.__field_zero2 
1783          except: 
1784              self.__field_zero2=UNKNOWN(**{'sizeinbytes': 6,  'pad': 0 }) 
1785          self.__field_zero2.writetobuffer(buf) 
1786          self.__field_numofnotes.writetobuffer(buf) 
1787          try: self.__field_zero3 
1788          except: 
1789              self.__field_zero3=UNKNOWN(**{'sizeinbytes': 2,  'pad': 0 }) 
1790          self.__field_zero3.writetobuffer(buf) 
1791          self.__field_numofactiveevents.writetobuffer(buf) 
1792          try: self.__field_zero4 
1793          except: 
1794              self.__field_zero4=UNKNOWN(**{'sizeinbytes': 112,  'pad': 0 }) 
1795          self.__field_zero4.writetobuffer(buf) 
1796          try: self.__field_events 
1797          except: 
1798              self.__field_events=LIST(**{ 'elementclass': CalIndexEntry,             'length': 103,             'createdefault': True }) 
1799          self.__field_events.writetobuffer(buf) 
1800          try: self.__field_notes 
1801          except: 
1802              self.__field_notes=LIST(**{ 'elementclass': CalIndexEntry,             'length': 30,             'createdefault': True }) 
1803          self.__field_notes.writetobuffer(buf) 
1804          try: self.__field_activeevents 
1805          except: 
1806              self.__field_activeevents=LIST(**{ 'elementclass': CalIndexEntry,             'length': 324,             'createdefault': True }) 
1807          self.__field_activeevents.writetobuffer(buf) 
1808          self._bufferendoffset=buf.getcurrentoffset() 
1809          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1810   
1811   
1812 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1813          'Reads this packet from the supplied buffer' 
1814          self._bufferstartoffset=buf.getcurrentoffset() 
1815          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1816          self.__field_next_index=UINT(**{'sizeinbytes': 2}) 
1817          self.__field_next_index.readfrombuffer(buf) 
1818          self.__field_zero1=UNKNOWN(**{'sizeinbytes': 12,  'pad': 0 }) 
1819          self.__field_zero1.readfrombuffer(buf) 
1820          self.__field_numofevents=UINT(**{'sizeinbytes': 2}) 
1821          self.__field_numofevents.readfrombuffer(buf) 
1822          self.__field_zero2=UNKNOWN(**{'sizeinbytes': 6,  'pad': 0 }) 
1823          self.__field_zero2.readfrombuffer(buf) 
1824          self.__field_numofnotes=UINT(**{'sizeinbytes': 2}) 
1825          self.__field_numofnotes.readfrombuffer(buf) 
1826          self.__field_zero3=UNKNOWN(**{'sizeinbytes': 2,  'pad': 0 }) 
1827          self.__field_zero3.readfrombuffer(buf) 
1828          self.__field_numofactiveevents=UINT(**{'sizeinbytes': 2}) 
1829          self.__field_numofactiveevents.readfrombuffer(buf) 
1830          self.__field_zero4=UNKNOWN(**{'sizeinbytes': 112,  'pad': 0 }) 
1831          self.__field_zero4.readfrombuffer(buf) 
1832          self.__field_events=LIST(**{ 'elementclass': CalIndexEntry,             'length': 103,             'createdefault': True }) 
1833          self.__field_events.readfrombuffer(buf) 
1834          self.__field_notes=LIST(**{ 'elementclass': CalIndexEntry,             'length': 30,             'createdefault': True }) 
1835          self.__field_notes.readfrombuffer(buf) 
1836          self.__field_activeevents=LIST(**{ 'elementclass': CalIndexEntry,             'length': 324,             'createdefault': True }) 
1837          self.__field_activeevents.readfrombuffer(buf) 
1838          self._bufferendoffset=buf.getcurrentoffset() 
1839   
1840   
1841 -    def __getfield_next_index(self): 
1842          return self.__field_next_index.getvalue() 
1843   
1844 -    def __setfield_next_index(self, value): 
1845          if isinstance(value,UINT): 
1846              self.__field_next_index=value 
1847          else: 
1848              self.__field_next_index=UINT(value,**{'sizeinbytes': 2}) 
1849   
1850 -    def __delfield_next_index(self): del self.__field_next_index 
1851   
1852      next_index=property(__getfield_next_index, __setfield_next_index, __delfield_next_index, None) 
1853   
1854 -    def __getfield_zero1(self): 
1855          try: self.__field_zero1 
1856          except: 
1857              self.__field_zero1=UNKNOWN(**{'sizeinbytes': 12,  'pad': 0 }) 
1858          return self.__field_zero1.getvalue() 
1859   
1860 -    def __setfield_zero1(self, value): 
1861          if isinstance(value,UNKNOWN): 
1862              self.__field_zero1=value 
1863          else: 
1864              self.__field_zero1=UNKNOWN(value,**{'sizeinbytes': 12,  'pad': 0 }) 
1865   
1866 -    def __delfield_zero1(self): del self.__field_zero1 
1867   
1868      zero1=property(__getfield_zero1, __setfield_zero1, __delfield_zero1, None) 
1869   
1870 -    def __getfield_numofevents(self): 
1871          return self.__field_numofevents.getvalue() 
1872   
1873 -    def __setfield_numofevents(self, value): 
1874          if isinstance(value,UINT): 
1875              self.__field_numofevents=value 
1876          else: 
1877              self.__field_numofevents=UINT(value,**{'sizeinbytes': 2}) 
1878   
1879 -    def __delfield_numofevents(self): del self.__field_numofevents 
1880   
1881      numofevents=property(__getfield_numofevents, __setfield_numofevents, __delfield_numofevents, None) 
1882   
1883 -    def __getfield_zero2(self): 
1884          try: self.__field_zero2 
1885          except: 
1886              self.__field_zero2=UNKNOWN(**{'sizeinbytes': 6,  'pad': 0 }) 
1887          return self.__field_zero2.getvalue() 
1888   
1889 -    def __setfield_zero2(self, value): 
1890          if isinstance(value,UNKNOWN): 
1891              self.__field_zero2=value 
1892          else: 
1893              self.__field_zero2=UNKNOWN(value,**{'sizeinbytes': 6,  'pad': 0 }) 
1894   
1895 -    def __delfield_zero2(self): del self.__field_zero2 
1896   
1897      zero2=property(__getfield_zero2, __setfield_zero2, __delfield_zero2, None) 
1898   
1899 -    def __getfield_numofnotes(self): 
1900          return self.__field_numofnotes.getvalue() 
1901   
1902 -    def __setfield_numofnotes(self, value): 
1903          if isinstance(value,UINT): 
1904              self.__field_numofnotes=value 
1905          else: 
1906              self.__field_numofnotes=UINT(value,**{'sizeinbytes': 2}) 
1907   
1908 -    def __delfield_numofnotes(self): del self.__field_numofnotes 
1909   
1910      numofnotes=property(__getfield_numofnotes, __setfield_numofnotes, __delfield_numofnotes, None) 
1911   
1912 -    def __getfield_zero3(self): 
1913          try: self.__field_zero3 
1914          except: 
1915              self.__field_zero3=UNKNOWN(**{'sizeinbytes': 2,  'pad': 0 }) 
1916          return self.__field_zero3.getvalue() 
1917   
1918 -    def __setfield_zero3(self, value): 
1919          if isinstance(value,UNKNOWN): 
1920              self.__field_zero3=value 
1921          else: 
1922              self.__field_zero3=UNKNOWN(value,**{'sizeinbytes': 2,  'pad': 0 }) 
1923   
1924 -    def __delfield_zero3(self): del self.__field_zero3 
1925   
1926      zero3=property(__getfield_zero3, __setfield_zero3, __delfield_zero3, None) 
1927   
1928 -    def __getfield_numofactiveevents(self): 
1929          return self.__field_numofactiveevents.getvalue() 
1930   
1931 -    def __setfield_numofactiveevents(self, value): 
1932          if isinstance(value,UINT): 
1933              self.__field_numofactiveevents=value 
1934          else: 
1935              self.__field_numofactiveevents=UINT(value,**{'sizeinbytes': 2}) 
1936   
1937 -    def __delfield_numofactiveevents(self): del self.__field_numofactiveevents 
1938   
1939      numofactiveevents=property(__getfield_numofactiveevents, __setfield_numofactiveevents, __delfield_numofactiveevents, None) 
1940   
1941 -    def __getfield_zero4(self): 
1942          try: self.__field_zero4 
1943          except: 
1944              self.__field_zero4=UNKNOWN(**{'sizeinbytes': 112,  'pad': 0 }) 
1945          return self.__field_zero4.getvalue() 
1946   
1947 -    def __setfield_zero4(self, value): 
1948          if isinstance(value,UNKNOWN): 
1949              self.__field_zero4=value 
1950          else: 
1951              self.__field_zero4=UNKNOWN(value,**{'sizeinbytes': 112,  'pad': 0 }) 
1952   
1953 -    def __delfield_zero4(self): del self.__field_zero4 
1954   
1955      zero4=property(__getfield_zero4, __setfield_zero4, __delfield_zero4, None) 
1956   
1957 -    def __getfield_events(self): 
1958          try: self.__field_events 
1959          except: 
1960              self.__field_events=LIST(**{ 'elementclass': CalIndexEntry,             'length': 103,             'createdefault': True }) 
1961          return self.__field_events.getvalue() 
1962   
1963 -    def __setfield_events(self, value): 
1964          if isinstance(value,LIST): 
1965              self.__field_events=value 
1966          else: 
1967              self.__field_events=LIST(value,**{ 'elementclass': CalIndexEntry,             'length': 103,             'createdefault': True }) 
1968   
1969 -    def __delfield_events(self): del self.__field_events 
1970   
1971      events=property(__getfield_events, __setfield_events, __delfield_events, None) 
1972   
1973 -    def __getfield_notes(self): 
1974          try: self.__field_notes 
1975          except: 
1976              self.__field_notes=LIST(**{ 'elementclass': CalIndexEntry,             'length': 30,             'createdefault': True }) 
1977          return self.__field_notes.getvalue() 
1978   
1979 -    def __setfield_notes(self, value): 
1980          if isinstance(value,LIST): 
1981              self.__field_notes=value 
1982          else: 
1983              self.__field_notes=LIST(value,**{ 'elementclass': CalIndexEntry,             'length': 30,             'createdefault': True }) 
1984   
1985 -    def __delfield_notes(self): del self.__field_notes 
1986   
1987      notes=property(__getfield_notes, __setfield_notes, __delfield_notes, None) 
1988   
1989 -    def __getfield_activeevents(self): 
1990          try: self.__field_activeevents 
1991          except: 
1992              self.__field_activeevents=LIST(**{ 'elementclass': CalIndexEntry,             'length': 324,             'createdefault': True }) 
1993          return self.__field_activeevents.getvalue() 
1994   
1995 -    def __setfield_activeevents(self, value): 
1996          if isinstance(value,LIST): 
1997              self.__field_activeevents=value 
1998          else: 
1999              self.__field_activeevents=LIST(value,**{ 'elementclass': CalIndexEntry,             'length': 324,             'createdefault': True }) 
2000   
2001 -    def __delfield_activeevents(self): del self.__field_activeevents 
2002   
2003      activeevents=property(__getfield_activeevents, __setfield_activeevents, __delfield_activeevents, None) 
2004   
2005 -    def iscontainer(self): 
2006          return True 
2007   
2008 -    def containerelements(self): 
2009          yield ('next_index', self.__field_next_index, None) 
2010          yield ('zero1', self.__field_zero1, None) 
2011          yield ('numofevents', self.__field_numofevents, None) 
2012          yield ('zero2', self.__field_zero2, None) 
2013          yield ('numofnotes', self.__field_numofnotes, None) 
2014          yield ('zero3', self.__field_zero3, None) 
2015          yield ('numofactiveevents', self.__field_numofactiveevents, None) 
2016          yield ('zero4', self.__field_zero4, None) 
2017          yield ('events', self.__field_events, None) 
2018          yield ('notes', self.__field_notes, None) 
2019          yield ('activeevents', self.__field_activeevents, None) 
2020   
2021   
2022   
2023   
2024 -class CalEntry(BaseProtogenClass): 
2025      __fields=['titlelen', 'title', 'start', 'zero1', 'start2', 'zero2', 'exptime', 'zero3', 'one', 'repeat', 'three', 'alarm', 'alert', 'zero4', 'duration', 'timezone', 'creationtime', 'zero5', 'modifiedtime', 'zero6', 'ringtonelen', 'ringtone', 'zero7'] 
2026   
2027 -    def __init__(self, *args, **kwargs): 
2028          dict={} 
2029          # What was supplied to this function 
2030          dict.update(kwargs) 
2031          # Parent constructor 
2032          super(CalEntry,self).__init__(**dict) 
2033          if self.__class__ is CalEntry: 
2034              self._update(args,dict) 
2035   
2036   
2037 -    def getfields(self): 
2038          return self.__fields 
2039   
2040   
2041 -    def _update(self, args, kwargs): 
2042          super(CalEntry,self)._update(args,kwargs) 
2043          keys=kwargs.keys() 
2044          for key in keys: 
2045              if key in self.__fields: 
2046                  setattr(self, key, kwargs[key]) 
2047                  del kwargs[key] 
2048          # Were any unrecognized kwargs passed in? 
2049          if __debug__: 
2050              self._complainaboutunusedargs(CalEntry,kwargs) 
2051          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2052          # Make all P fields that haven't already been constructed 
2053   
2054   
2055 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2056          'Writes this packet to the supplied buffer' 
2057          self._bufferstartoffset=buf.getcurrentoffset() 
2058          self.__field_titlelen.writetobuffer(buf) 
2059          self.__field_title.writetobuffer(buf) 
2060          self.__field_start.writetobuffer(buf) 
2061          try: self.__field_zero1 
2062          except: 
2063              self.__field_zero1=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 }) 
2064          self.__field_zero1.writetobuffer(buf) 
2065          try: self.__field_start2 
2066          except: 
2067              self.__field_start2=DateTime(**{'sizeinbytes': 4,  'default': self.start }) 
2068          self.__field_start2.writetobuffer(buf) 
2069          try: self.__field_zero2 
2070          except: 
2071              self.__field_zero2=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 }) 
2072          self.__field_zero2.writetobuffer(buf) 
2073          self.__field_exptime.writetobuffer(buf) 
2074          try: self.__field_zero3 
2075          except: 
2076              self.__field_zero3=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 }) 
2077          self.__field_zero3.writetobuffer(buf) 
2078          try: self.__field_one 
2079          except: 
2080              self.__field_one=UINT(**{'sizeinbytes': 1,  'default': 1 }) 
2081          self.__field_one.writetobuffer(buf) 
2082          self.__field_repeat.writetobuffer(buf) 
2083          try: self.__field_three 
2084          except: 
2085              self.__field_three=UINT(**{'sizeinbytes': 1,  'default': 3 }) 
2086          self.__field_three.writetobuffer(buf) 
2087          self.__field_alarm.writetobuffer(buf) 
2088          self.__field_alert.writetobuffer(buf) 
2089          try: self.__field_zero4 
2090          except: 
2091              self.__field_zero4=UNKNOWN(**{'sizeinbytes': 6,  'pad': 0 }) 
2092          self.__field_zero4.writetobuffer(buf) 
2093          self.__field_duration.writetobuffer(buf) 
2094          self.__field_timezone.writetobuffer(buf) 
2095          self.__field_creationtime.writetobuffer(buf) 
2096          try: self.__field_zero5 
2097          except: 
2098              self.__field_zero5=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 }) 
2099          self.__field_zero5.writetobuffer(buf) 
2100          self.__field_modifiedtime.writetobuffer(buf) 
2101          try: self.__field_zero6 
2102          except: 
2103              self.__field_zero6=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 }) 
2104          self.__field_zero6.writetobuffer(buf) 
2105          self.__field_ringtonelen.writetobuffer(buf) 
2106          self.__field_ringtone.writetobuffer(buf) 
2107          try: self.__field_zero7 
2108          except: 
2109              self.__field_zero7=UNKNOWN(**{'sizeinbytes': 2,  'pad': 0 }) 
2110          self.__field_zero7.writetobuffer(buf) 
2111          self._bufferendoffset=buf.getcurrentoffset() 
2112          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2113   
2114   
2115 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2116          'Reads this packet from the supplied buffer' 
2117          self._bufferstartoffset=buf.getcurrentoffset() 
2118          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2119          self.__field_titlelen=UINT(**{'sizeinbytes': 2}) 
2120          self.__field_titlelen.readfrombuffer(buf) 
2121          self.__field_title=USTRING(**{ 'sizeinbytes': self.titlelen,                'encoding': ENCODING,                'terminator': None }) 
2122          self.__field_title.readfrombuffer(buf) 
2123          self.__field_start=DateTime(**{'sizeinbytes': 4}) 
2124          self.__field_start.readfrombuffer(buf) 
2125          self.__field_zero1=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 }) 
2126          self.__field_zero1.readfrombuffer(buf) 
2127          self.__field_start2=DateTime(**{'sizeinbytes': 4,  'default': self.start }) 
2128          self.__field_start2.readfrombuffer(buf) 
2129          self.__field_zero2=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 }) 
2130          self.__field_zero2.readfrombuffer(buf) 
2131          self.__field_exptime=ExpiringTime(**{'sizeinbytes': 4}) 
2132          self.__field_exptime.readfrombuffer(buf) 
2133          self.__field_zero3=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 }) 
2134          self.__field_zero3.readfrombuffer(buf) 
2135          self.__field_one=UINT(**{'sizeinbytes': 1,  'default': 1 }) 
2136          self.__field_one.readfrombuffer(buf) 
2137          self.__field_repeat=UINT(**{'sizeinbytes': 1}) 
2138          self.__field_repeat.readfrombuffer(buf) 
2139          self.__field_three=UINT(**{'sizeinbytes': 1,  'default': 3 }) 
2140          self.__field_three.readfrombuffer(buf) 
2141          self.__field_alarm=UINT(**{'sizeinbytes': 1}) 
2142          self.__field_alarm.readfrombuffer(buf) 
2143          self.__field_alert=UINT(**{'sizeinbytes': 1}) 
2144          self.__field_alert.readfrombuffer(buf) 
2145          self.__field_zero4=UNKNOWN(**{'sizeinbytes': 6,  'pad': 0 }) 
2146          self.__field_zero4.readfrombuffer(buf) 
2147          self.__field_duration=UINT(**{'sizeinbytes': 4}) 
2148          self.__field_duration.readfrombuffer(buf) 
2149          self.__field_timezone=UINT(**{'sizeinbytes': 1}) 
2150          self.__field_timezone.readfrombuffer(buf) 
2151          self.__field_creationtime=DateTime(**{'sizeinbytes': 4}) 
2152          self.__field_creationtime.readfrombuffer(buf) 
2153          self.__field_zero5=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 }) 
2154          self.__field_zero5.readfrombuffer(buf) 
2155          self.__field_modifiedtime=DateTime(**{'sizeinbytes': 4}) 
2156          self.__field_modifiedtime.readfrombuffer(buf) 
2157          self.__field_zero6=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 }) 
2158          self.__field_zero6.readfrombuffer(buf) 
2159          self.__field_ringtonelen=UINT(**{'sizeinbytes': 2}) 
2160          self.__field_ringtonelen.readfrombuffer(buf) 
2161          self.__field_ringtone=STRING(**{ 'sizeinbytes': self.ringtonelen,               'terminator': None }) 
2162          self.__field_ringtone.readfrombuffer(buf) 
2163          self.__field_zero7=UNKNOWN(**{'sizeinbytes': 2,  'pad': 0 }) 
2164          self.__field_zero7.readfrombuffer(buf) 
2165          self._bufferendoffset=buf.getcurrentoffset() 
2166   
2167   
2168 -    def __getfield_titlelen(self): 
2169          return self.__field_titlelen.getvalue() 
2170   
2171 -    def __setfield_titlelen(self, value): 
2172          if isinstance(value,UINT): 
2173              self.__field_titlelen=value 
2174          else: 
2175              self.__field_titlelen=UINT(value,**{'sizeinbytes': 2}) 
2176   
2177 -    def __delfield_titlelen(self): del self.__field_titlelen 
2178   
2179      titlelen=property(__getfield_titlelen, __setfield_titlelen, __delfield_titlelen, None) 
2180   
2181 -    def __getfield_title(self): 
2182          return self.__field_title.getvalue() 
2183   
2184 -    def __setfield_title(self, value): 
2185          if isinstance(value,USTRING): 
2186              self.__field_title=value 
2187          else: 
2188              self.__field_title=USTRING(value,**{ 'sizeinbytes': self.titlelen,                'encoding': ENCODING,                'terminator': None }) 
2189   
2190 -    def __delfield_title(self): del self.__field_title 
2191   
2192      title=property(__getfield_title, __setfield_title, __delfield_title, None) 
2193   
2194 -    def __getfield_start(self): 
2195          return self.__field_start.getvalue() 
2196   
2197 -    def __setfield_start(self, value): 
2198          if isinstance(value,DateTime): 
2199              self.__field_start=value 
2200          else: 
2201              self.__field_start=DateTime(value,**{'sizeinbytes': 4}) 
2202   
2203 -    def __delfield_start(self): del self.__field_start 
2204   
2205      start=property(__getfield_start, __setfield_start, __delfield_start, None) 
2206   
2207 -    def __getfield_zero1(self): 
2208          try: self.__field_zero1 
2209          except: 
2210              self.__field_zero1=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 }) 
2211          return self.__field_zero1.getvalue() 
2212   
2213 -    def __setfield_zero1(self, value): 
2214          if isinstance(value,UNKNOWN): 
2215              self.__field_zero1=value 
2216          else: 
2217              self.__field_zero1=UNKNOWN(value,**{'sizeinbytes': 4,  'pad': 0 }) 
2218   
2219 -    def __delfield_zero1(self): del self.__field_zero1 
2220   
2221      zero1=property(__getfield_zero1, __setfield_zero1, __delfield_zero1, None) 
2222   
2223 -    def __getfield_start2(self): 
2224          try: self.__field_start2 
2225          except: 
2226              self.__field_start2=DateTime(**{'sizeinbytes': 4,  'default': self.start }) 
2227          return self.__field_start2.getvalue() 
2228   
2229 -    def __setfield_start2(self, value): 
2230          if isinstance(value,DateTime): 
2231              self.__field_start2=value 
2232          else: 
2233              self.__field_start2=DateTime(value,**{'sizeinbytes': 4,  'default': self.start }) 
2234   
2235 -    def __delfield_start2(self): del self.__field_start2 
2236   
2237      start2=property(__getfield_start2, __setfield_start2, __delfield_start2, None) 
2238   
2239 -    def __getfield_zero2(self): 
2240          try: self.__field_zero2 
2241          except: 
2242              self.__field_zero2=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 }) 
2243          return self.__field_zero2.getvalue() 
2244   
2245 -    def __setfield_zero2(self, value): 
2246          if isinstance(value,UNKNOWN): 
2247              self.__field_zero2=value 
2248          else: 
2249              self.__field_zero2=UNKNOWN(value,**{'sizeinbytes': 4,  'pad': 0 }) 
2250   
2251 -    def __delfield_zero2(self): del self.__field_zero2 
2252   
2253      zero2=property(__getfield_zero2, __setfield_zero2, __delfield_zero2, None) 
2254   
2255 -    def __getfield_exptime(self): 
2256          return self.__field_exptime.getvalue() 
2257   
2258 -    def __setfield_exptime(self, value): 
2259          if isinstance(value,ExpiringTime): 
2260              self.__field_exptime=value 
2261          else: 
2262              self.__field_exptime=ExpiringTime(value,**{'sizeinbytes': 4}) 
2263   
2264 -    def __delfield_exptime(self): del self.__field_exptime 
2265   
2266      exptime=property(__getfield_exptime, __setfield_exptime, __delfield_exptime, None) 
2267   
2268 -    def __getfield_zero3(self): 
2269          try: self.__field_zero3 
2270          except: 
2271              self.__field_zero3=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 }) 
2272          return self.__field_zero3.getvalue() 
2273   
2274 -    def __setfield_zero3(self, value): 
2275          if isinstance(value,UNKNOWN): 
2276              self.__field_zero3=value 
2277          else: 
2278              self.__field_zero3=UNKNOWN(value,**{'sizeinbytes': 4,  'pad': 0 }) 
2279   
2280 -    def __delfield_zero3(self): del self.__field_zero3 
2281   
2282      zero3=property(__getfield_zero3, __setfield_zero3, __delfield_zero3, None) 
2283   
2284 -    def __getfield_one(self): 
2285          try: self.__field_one 
2286          except: 
2287              self.__field_one=UINT(**{'sizeinbytes': 1,  'default': 1 }) 
2288          return self.__field_one.getvalue() 
2289   
2290 -    def __setfield_one(self, value): 
2291          if isinstance(value,UINT): 
2292              self.__field_one=value 
2293          else: 
2294              self.__field_one=UINT(value,**{'sizeinbytes': 1,  'default': 1 }) 
2295   
2296 -    def __delfield_one(self): del self.__field_one 
2297   
2298      one=property(__getfield_one, __setfield_one, __delfield_one, None) 
2299   
2300 -    def __getfield_repeat(self): 
2301          return self.__field_repeat.getvalue() 
2302   
2303 -    def __setfield_repeat(self, value): 
2304          if isinstance(value,UINT): 
2305              self.__field_repeat=value 
2306          else: 
2307              self.__field_repeat=UINT(value,**{'sizeinbytes': 1}) 
2308   
2309 -    def __delfield_repeat(self): del self.__field_repeat 
2310   
2311      repeat=property(__getfield_repeat, __setfield_repeat, __delfield_repeat, None) 
2312   
2313 -    def __getfield_three(self): 
2314          try: self.__field_three 
2315          except: 
2316              self.__field_three=UINT(**{'sizeinbytes': 1,  'default': 3 }) 
2317          return self.__field_three.getvalue() 
2318   
2319 -    def __setfield_three(self, value): 
2320          if isinstance(value,UINT): 
2321              self.__field_three=value 
2322          else: 
2323              self.__field_three=UINT(value,**{'sizeinbytes': 1,  'default': 3 }) 
2324   
2325 -    def __delfield_three(self): del self.__field_three 
2326   
2327      three=property(__getfield_three, __setfield_three, __delfield_three, None) 
2328   
2329 -    def __getfield_alarm(self): 
2330          return self.__field_alarm.getvalue() 
2331   
2332 -    def __setfield_alarm(self, value): 
2333          if isinstance(value,UINT): 
2334              self.__field_alarm=value 
2335          else: 
2336              self.__field_alarm=UINT(value,**{'sizeinbytes': 1}) 
2337   
2338 -    def __delfield_alarm(self): del self.__field_alarm 
2339   
2340      alarm=property(__getfield_alarm, __setfield_alarm, __delfield_alarm, None) 
2341   
2342 -    def __getfield_alert(self): 
2343          return self.__field_alert.getvalue() 
2344   
2345 -    def __setfield_alert(self, value): 
2346          if isinstance(value,UINT): 
2347              self.__field_alert=value 
2348          else: 
2349              self.__field_alert=UINT(value,**{'sizeinbytes': 1}) 
2350   
2351 -    def __delfield_alert(self): del self.__field_alert 
2352   
2353      alert=property(__getfield_alert, __setfield_alert, __delfield_alert, None) 
2354   
2355 -    def __getfield_zero4(self): 
2356          try: self.__field_zero4 
2357          except: 
2358              self.__field_zero4=UNKNOWN(**{'sizeinbytes': 6,  'pad': 0 }) 
2359          return self.__field_zero4.getvalue() 
2360   
2361 -    def __setfield_zero4(self, value): 
2362          if isinstance(value,UNKNOWN): 
2363              self.__field_zero4=value 
2364          else: 
2365              self.__field_zero4=UNKNOWN(value,**{'sizeinbytes': 6,  'pad': 0 }) 
2366   
2367 -    def __delfield_zero4(self): del self.__field_zero4 
2368   
2369      zero4=property(__getfield_zero4, __setfield_zero4, __delfield_zero4, None) 
2370   
2371 -    def __getfield_duration(self): 
2372          return self.__field_duration.getvalue() 
2373   
2374 -    def __setfield_duration(self, value): 
2375          if isinstance(value,UINT): 
2376              self.__field_duration=value 
2377          else: 
2378              self.__field_duration=UINT(value,**{'sizeinbytes': 4}) 
2379   
2380 -    def __delfield_duration(self): del self.__field_duration 
2381   
2382      duration=property(__getfield_duration, __setfield_duration, __delfield_duration, None) 
2383   
2384 -    def __getfield_timezone(self): 
2385          return self.__field_timezone.getvalue() 
2386   
2387 -    def __setfield_timezone(self, value): 
2388          if isinstance(value,UINT): 
2389              self.__field_timezone=value 
2390          else: 
2391              self.__field_timezone=UINT(value,**{'sizeinbytes': 1}) 
2392   
2393 -    def __delfield_timezone(self): del self.__field_timezone 
2394   
2395      timezone=property(__getfield_timezone, __setfield_timezone, __delfield_timezone, None) 
2396   
2397 -    def __getfield_creationtime(self): 
2398          return self.__field_creationtime.getvalue() 
2399   
2400 -    def __setfield_creationtime(self, value): 
2401          if isinstance(value,DateTime): 
2402              self.__field_creationtime=value 
2403          else: 
2404              self.__field_creationtime=DateTime(value,**{'sizeinbytes': 4}) 
2405   
2406 -    def __delfield_creationtime(self): del self.__field_creationtime 
2407   
2408      creationtime=property(__getfield_creationtime, __setfield_creationtime, __delfield_creationtime, None) 
2409   
2410 -    def __getfield_zero5(self): 
2411          try: self.__field_zero5 
2412          except: 
2413              self.__field_zero5=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 }) 
2414          return self.__field_zero5.getvalue() 
2415   
2416 -    def __setfield_zero5(self, value): 
2417          if isinstance(value,UNKNOWN): 
2418              self.__field_zero5=value 
2419          else: 
2420              self.__field_zero5=UNKNOWN(value,**{'sizeinbytes': 4,  'pad': 0 }) 
2421   
2422 -    def __delfield_zero5(self): del self.__field_zero5 
2423   
2424      zero5=property(__getfield_zero5, __setfield_zero5, __delfield_zero5, None) 
2425   
2426 -    def __getfield_modifiedtime(self): 
2427          return self.__field_modifiedtime.getvalue() 
2428   
2429 -    def __setfield_modifiedtime(self, value): 
2430          if isinstance(value,DateTime): 
2431              self.__field_modifiedtime=value 
2432          else: 
2433              self.__field_modifiedtime=DateTime(value,**{'sizeinbytes': 4}) 
2434   
2435 -    def __delfield_modifiedtime(self): del self.__field_modifiedtime 
2436   
2437      modifiedtime=property(__getfield_modifiedtime, __setfield_modifiedtime, __delfield_modifiedtime, None) 
2438   
2439 -    def __getfield_zero6(self): 
2440          try: self.__field_zero6 
2441          except: 
2442              self.__field_zero6=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 }) 
2443          return self.__field_zero6.getvalue() 
2444   
2445 -    def __setfield_zero6(self, value): 
2446          if isinstance(value,UNKNOWN): 
2447              self.__field_zero6=value 
2448          else: 
2449              self.__field_zero6=UNKNOWN(value,**{'sizeinbytes': 4,  'pad': 0 }) 
2450   
2451 -    def __delfield_zero6(self): del self.__field_zero6 
2452   
2453      zero6=property(__getfield_zero6, __setfield_zero6, __delfield_zero6, None) 
2454   
2455 -    def __getfield_ringtonelen(self): 
2456          return self.__field_ringtonelen.getvalue() 
2457   
2458 -    def __setfield_ringtonelen(self, value): 
2459          if isinstance(value,UINT): 
2460              self.__field_ringtonelen=value 
2461          else: 
2462              self.__field_ringtonelen=UINT(value,**{'sizeinbytes': 2}) 
2463   
2464 -    def __delfield_ringtonelen(self): del self.__field_ringtonelen 
2465   
2466      ringtonelen=property(__getfield_ringtonelen, __setfield_ringtonelen, __delfield_ringtonelen, None) 
2467   
2468 -    def __getfield_ringtone(self): 
2469          return self.__field_ringtone.getvalue() 
2470   
2471 -    def __setfield_ringtone(self, value): 
2472          if isinstance(value,STRING): 
2473              self.__field_ringtone=value 
2474          else: 
2475              self.__field_ringtone=STRING(value,**{ 'sizeinbytes': self.ringtonelen,               'terminator': None }) 
2476   
2477 -    def __delfield_ringtone(self): del self.__field_ringtone 
2478   
2479      ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 
2480   
2481 -    def __getfield_zero7(self): 
2482          try: self.__field_zero7 
2483          except: 
2484              self.__field_zero7=UNKNOWN(**{'sizeinbytes': 2,  'pad': 0 }) 
2485          return self.__field_zero7.getvalue() 
2486   
2487 -    def __setfield_zero7(self, value): 
2488          if isinstance(value,UNKNOWN): 
2489              self.__field_zero7=value 
2490          else: 
2491              self.__field_zero7=UNKNOWN(value,**{'sizeinbytes': 2,  'pad': 0 }) 
2492   
2493 -    def __delfield_zero7(self): del self.__field_zero7 
2494   
2495      zero7=property(__getfield_zero7, __setfield_zero7, __delfield_zero7, None) 
2496   
2497 -    def iscontainer(self): 
2498          return True 
2499   
2500 -    def containerelements(self): 
2501          yield ('titlelen', self.__field_titlelen, None) 
2502          yield ('title', self.__field_title, None) 
2503          yield ('start', self.__field_start, None) 
2504          yield ('zero1', self.__field_zero1, None) 
2505          yield ('start2', self.__field_start2, None) 
2506          yield ('zero2', self.__field_zero2, None) 
2507          yield ('exptime', self.__field_exptime, None) 
2508          yield ('zero3', self.__field_zero3, None) 
2509          yield ('one', self.__field_one, None) 
2510          yield ('repeat', self.__field_repeat, None) 
2511          yield ('three', self.__field_three, None) 
2512          yield ('alarm', self.__field_alarm, None) 
2513          yield ('alert', self.__field_alert, None) 
2514          yield ('zero4', self.__field_zero4, None) 
2515          yield ('duration', self.__field_duration, None) 
2516          yield ('timezone', self.__field_timezone, None) 
2517          yield ('creationtime', self.__field_creationtime, None) 
2518          yield ('zero5', self.__field_zero5, None) 
2519          yield ('modifiedtime', self.__field_modifiedtime, None) 
2520          yield ('zero6', self.__field_zero6, None) 
2521          yield ('ringtonelen', self.__field_ringtonelen, None) 
2522          yield ('ringtone', self.__field_ringtone, None) 
2523          yield ('zero7', self.__field_zero7, None) 
2524   
2525   
2526   
2527   
2528 -class NotePadEntry(BaseProtogenClass): 
2529      __fields=['textlen', 'text', 'creation', 'zero1', 'creation2', 'zero2', 'five', 'zero3', 'modified', 'zero4', 'modified2', 'zero5'] 
2530   
2531 -    def __init__(self, *args, **kwargs): 
2532          dict={} 
2533          # What was supplied to this function 
2534          dict.update(kwargs) 
2535          # Parent constructor 
2536          super(NotePadEntry,self).__init__(**dict) 
2537          if self.__class__ is NotePadEntry: 
2538              self._update(args,dict) 
2539   
2540   
2541 -    def getfields(self): 
2542          return self.__fields 
2543   
2544   
2545 -    def _update(self, args, kwargs): 
2546          super(NotePadEntry,self)._update(args,kwargs) 
2547          keys=kwargs.keys() 
2548          for key in keys: 
2549              if key in self.__fields: 
2550                  setattr(self, key, kwargs[key]) 
2551                  del kwargs[key] 
2552          # Were any unrecognized kwargs passed in? 
2553          if __debug__: 
2554              self._complainaboutunusedargs(NotePadEntry,kwargs) 
2555          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2556          # Make all P fields that haven't already been constructed 
2557   
2558   
2559 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2560          'Writes this packet to the supplied buffer' 
2561          self._bufferstartoffset=buf.getcurrentoffset() 
2562          self.__field_textlen.writetobuffer(buf) 
2563          self.__field_text.writetobuffer(buf) 
2564          self.__field_creation.writetobuffer(buf) 
2565          try: self.__field_zero1 
2566          except: 
2567              self.__field_zero1=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 }) 
2568          self.__field_zero1.writetobuffer(buf) 
2569          try: self.__field_creation2 
2570          except: 
2571              self.__field_creation2=DateTime(**{'sizeinbytes': 4,  'default': self.creation }) 
2572          self.__field_creation2.writetobuffer(buf) 
2573          try: self.__field_zero2 
2574          except: 
2575              self.__field_zero2=UNKNOWN(**{'sizeinbytes': 14,  'pad': 0 }) 
2576          self.__field_zero2.writetobuffer(buf) 
2577          try: self.__field_five 
2578          except: 
2579              self.__field_five=UINT(**{'sizeinbytes': 1,  'default': 5 }) 
2580          self.__field_five.writetobuffer(buf) 
2581          try: self.__field_zero3 
2582          except: 
2583              self.__field_zero3=UNKNOWN(**{'sizeinbytes': 13,  'pad': 0 }) 
2584          self.__field_zero3.writetobuffer(buf) 
2585          try: self.__field_modified 
2586          except: 
2587              self.__field_modified=DateTime(**{'sizeinbytes': 4,  'default': self.creation }) 
2588          self.__field_modified.writetobuffer(buf) 
2589          try: self.__field_zero4 
2590          except: 
2591              self.__field_zero4=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 }) 
2592          self.__field_zero4.writetobuffer(buf) 
2593          try: self.__field_modified2 
2594          except: 
2595              self.__field_modified2=DateTime(**{'sizeinbytes': 4,  'default': self.modified }) 
2596          self.__field_modified2.writetobuffer(buf) 
2597          try: self.__field_zero5 
2598          except: 
2599              self.__field_zero5=UNKNOWN(**{'sizeinbytes': 8,  'pad': 0 }) 
2600          self.__field_zero5.writetobuffer(buf) 
2601          self._bufferendoffset=buf.getcurrentoffset() 
2602          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2603   
2604   
2605 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2606          'Reads this packet from the supplied buffer' 
2607          self._bufferstartoffset=buf.getcurrentoffset() 
2608          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2609          self.__field_textlen=UINT(**{'sizeinbytes': 2}) 
2610          self.__field_textlen.readfrombuffer(buf) 
2611          self.__field_text=USTRING(**{ 'terminator': None,                'encoding': ENCODING,                'sizeinbytes': self.textlen }) 
2612          self.__field_text.readfrombuffer(buf) 
2613          self.__field_creation=DateTime(**{'sizeinbytes': 4}) 
2614          self.__field_creation.readfrombuffer(buf) 
2615          self.__field_zero1=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 }) 
2616          self.__field_zero1.readfrombuffer(buf) 
2617          self.__field_creation2=DateTime(**{'sizeinbytes': 4,  'default': self.creation }) 
2618          self.__field_creation2.readfrombuffer(buf) 
2619          self.__field_zero2=UNKNOWN(**{'sizeinbytes': 14,  'pad': 0 }) 
2620          self.__field_zero2.readfrombuffer(buf) 
2621          self.__field_five=UINT(**{'sizeinbytes': 1,  'default': 5 }) 
2622          self.__field_five.readfrombuffer(buf) 
2623          self.__field_zero3=UNKNOWN(**{'sizeinbytes': 13,  'pad': 0 }) 
2624          self.__field_zero3.readfrombuffer(buf) 
2625          self.__field_modified=DateTime(**{'sizeinbytes': 4,  'default': self.creation }) 
2626          self.__field_modified.readfrombuffer(buf) 
2627          self.__field_zero4=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 }) 
2628          self.__field_zero4.readfrombuffer(buf) 
2629          self.__field_modified2=DateTime(**{'sizeinbytes': 4,  'default': self.modified }) 
2630          self.__field_modified2.readfrombuffer(buf) 
2631          self.__field_zero5=UNKNOWN(**{'sizeinbytes': 8,  'pad': 0 }) 
2632          self.__field_zero5.readfrombuffer(buf) 
2633          self._bufferendoffset=buf.getcurrentoffset() 
2634   
2635   
2636 -    def __getfield_textlen(self): 
2637          return self.__field_textlen.getvalue() 
2638   
2639 -    def __setfield_textlen(self, value): 
2640          if isinstance(value,UINT): 
2641              self.__field_textlen=value 
2642          else: 
2643              self.__field_textlen=UINT(value,**{'sizeinbytes': 2}) 
2644   
2645 -    def __delfield_textlen(self): del self.__field_textlen 
2646   
2647      textlen=property(__getfield_textlen, __setfield_textlen, __delfield_textlen, None) 
2648   
2649 -    def __getfield_text(self): 
2650          return self.__field_text.getvalue() 
2651   
2652 -    def __setfield_text(self, value): 
2653          if isinstance(value,USTRING): 
2654              self.__field_text=value 
2655          else: 
2656              self.__field_text=USTRING(value,**{ 'terminator': None,                'encoding': ENCODING,                'sizeinbytes': self.textlen }) 
2657   
2658 -    def __delfield_text(self): del self.__field_text 
2659   
2660      text=property(__getfield_text, __setfield_text, __delfield_text, None) 
2661   
2662 -    def __getfield_creation(self): 
2663          return self.__field_creation.getvalue() 
2664   
2665 -    def __setfield_creation(self, value): 
2666          if isinstance(value,DateTime): 
2667              self.__field_creation=value 
2668          else: 
2669              self.__field_creation=DateTime(value,**{'sizeinbytes': 4}) 
2670   
2671 -    def __delfield_creation(self): del self.__field_creation 
2672   
2673      creation=property(__getfield_creation, __setfield_creation, __delfield_creation, None) 
2674   
2675 -    def __getfield_zero1(self): 
2676          try: self.__field_zero1 
2677          except: 
2678              self.__field_zero1=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 }) 
2679          return self.__field_zero1.getvalue() 
2680   
2681 -    def __setfield_zero1(self, value): 
2682          if isinstance(value,UNKNOWN): 
2683              self.__field_zero1=value 
2684          else: 
2685              self.__field_zero1=UNKNOWN(value,**{'sizeinbytes': 4,  'pad': 0 }) 
2686   
2687 -    def __delfield_zero1(self): del self.__field_zero1 
2688   
2689      zero1=property(__getfield_zero1, __setfield_zero1, __delfield_zero1, None) 
2690   
2691 -    def __getfield_creation2(self): 
2692          try: self.__field_creation2 
2693          except: 
2694              self.__field_creation2=DateTime(**{'sizeinbytes': 4,  'default': self.creation }) 
2695          return self.__field_creation2.getvalue() 
2696   
2697 -    def __setfield_creation2(self, value): 
2698          if isinstance(value,DateTime): 
2699              self.__field_creation2=value 
2700          else: 
2701              self.__field_creation2=DateTime(value,**{'sizeinbytes': 4,  'default': self.creation }) 
2702   
2703 -    def __delfield_creation2(self): del self.__field_creation2 
2704   
2705      creation2=property(__getfield_creation2, __setfield_creation2, __delfield_creation2, None) 
2706   
2707 -    def __getfield_zero2(self): 
2708          try: self.__field_zero2 
2709          except: 
2710              self.__field_zero2=UNKNOWN(**{'sizeinbytes': 14,  'pad': 0 }) 
2711          return self.__field_zero2.getvalue() 
2712   
2713 -    def __setfield_zero2(self, value): 
2714          if isinstance(value,UNKNOWN): 
2715              self.__field_zero2=value 
2716          else: 
2717              self.__field_zero2=UNKNOWN(value,**{'sizeinbytes': 14,  'pad': 0 }) 
2718   
2719 -    def __delfield_zero2(self): del self.__field_zero2 
2720   
2721      zero2=property(__getfield_zero2, __setfield_zero2, __delfield_zero2, None) 
2722   
2723 -    def __getfield_five(self): 
2724          try: self.__field_five 
2725          except: 
2726              self.__field_five=UINT(**{'sizeinbytes': 1,  'default': 5 }) 
2727          return self.__field_five.getvalue() 
2728   
2729 -    def __setfield_five(self, value): 
2730          if isinstance(value,UINT): 
2731              self.__field_five=value 
2732          else: 
2733              self.__field_five=UINT(value,**{'sizeinbytes': 1,  'default': 5 }) 
2734   
2735 -    def __delfield_five(self): del self.__field_five 
2736   
2737      five=property(__getfield_five, __setfield_five, __delfield_five, None) 
2738   
2739 -    def __getfield_zero3(self): 
2740          try: self.__field_zero3 
2741          except: 
2742              self.__field_zero3=UNKNOWN(**{'sizeinbytes': 13,  'pad': 0 }) 
2743          return self.__field_zero3.getvalue() 
2744   
2745 -    def __setfield_zero3(self, value): 
2746          if isinstance(value,UNKNOWN): 
2747              self.__field_zero3=value 
2748          else: 
2749              self.__field_zero3=UNKNOWN(value,**{'sizeinbytes': 13,  'pad': 0 }) 
2750   
2751 -    def __delfield_zero3(self): del self.__field_zero3 
2752   
2753      zero3=property(__getfield_zero3, __setfield_zero3, __delfield_zero3, None) 
2754   
2755 -    def __getfield_modified(self): 
2756          try: self.__field_modified 
2757          except: 
2758              self.__field_modified=DateTime(**{'sizeinbytes': 4,  'default': self.creation }) 
2759          return self.__field_modified.getvalue() 
2760   
2761 -    def __setfield_modified(self, value): 
2762          if isinstance(value,DateTime): 
2763              self.__field_modified=value 
2764          else: 
2765              self.__field_modified=DateTime(value,**{'sizeinbytes': 4,  'default': self.creation }) 
2766   
2767 -    def __delfield_modified(self): del self.__field_modified 
2768   
2769      modified=property(__getfield_modified, __setfield_modified, __delfield_modified, None) 
2770   
2771 -    def __getfield_zero4(self): 
2772          try: self.__field_zero4 
2773          except: 
2774              self.__field_zero4=UNKNOWN(**{'sizeinbytes': 4,  'pad': 0 }) 
2775          return self.__field_zero4.getvalue() 
2776   
2777 -    def __setfield_zero4(self, value): 
2778          if isinstance(value,UNKNOWN): 
2779              self.__field_zero4=value 
2780          else: 
2781              self.__field_zero4=UNKNOWN(value,**{'sizeinbytes': 4,  'pad': 0 }) 
2782   
2783 -    def __delfield_zero4(self): del self.__field_zero4 
2784   
2785      zero4=property(__getfield_zero4, __setfield_zero4, __delfield_zero4, None) 
2786   
2787 -    def __getfield_modified2(self): 
2788          try: self.__field_modified2 
2789          except: 
2790              self.__field_modified2=DateTime(**{'sizeinbytes': 4,  'default': self.modified }) 
2791          return self.__field_modified2.getvalue() 
2792   
2793 -    def __setfield_modified2(self, value): 
2794          if isinstance(value,DateTime): 
2795              self.__field_modified2=value 
2796          else: 
2797              self.__field_modified2=DateTime(value,**{'sizeinbytes': 4,  'default': self.modified }) 
2798   
2799 -    def __delfield_modified2(self): del self.__field_modified2 
2800   
2801      modified2=property(__getfield_modified2, __setfield_modified2, __delfield_modified2, None) 
2802   
2803 -    def __getfield_zero5(self): 
2804          try: self.__field_zero5 
2805          except: 
2806              self.__field_zero5=UNKNOWN(**{'sizeinbytes': 8,  'pad': 0 }) 
2807          return self.__field_zero5.getvalue() 
2808   
2809 -    def __setfield_zero5(self, value): 
2810          if isinstance(value,UNKNOWN): 
2811              self.__field_zero5=value 
2812          else: 
2813              self.__field_zero5=UNKNOWN(value,**{'sizeinbytes': 8,  'pad': 0 }) 
2814   
2815 -    def __delfield_zero5(self): del self.__field_zero5 
2816   
2817      zero5=property(__getfield_zero5, __setfield_zero5, __delfield_zero5, None) 
2818   
2819 -    def iscontainer(self): 
2820          return True 
2821   
2822 -    def containerelements(self): 
2823          yield ('textlen', self.__field_textlen, None) 
2824          yield ('text', self.__field_text, None) 
2825          yield ('creation', self.__field_creation, None) 
2826          yield ('zero1', self.__field_zero1, None) 
2827          yield ('creation2', self.__field_creation2, None) 
2828          yield ('zero2', self.__field_zero2, None) 
2829          yield ('five', self.__field_five, None) 
2830          yield ('zero3', self.__field_zero3, None) 
2831          yield ('modified', self.__field_modified, None) 
2832          yield ('zero4', self.__field_zero4, None) 
2833          yield ('modified2', self.__field_modified2, None) 
2834          yield ('zero5', self.__field_zero5, None) 
2835   
2836   
2837   
2838   
2839 -class JournalNumber(BaseProtogenClass): 
2840      __fields=['index', 'bitmap'] 
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(JournalNumber,self).__init__(**dict) 
2848          if self.__class__ is JournalNumber: 
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(JournalNumber,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(JournalNumber,kwargs) 
2866          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2867          # Make all P fields that haven't already been constructed 
2868   
2869   
2870 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2871          'Writes this packet to the supplied buffer' 
2872          self._bufferstartoffset=buf.getcurrentoffset() 
2873          self.__field_index.writetobuffer(buf) 
2874          self.__field_bitmap.writetobuffer(buf) 
2875          self._bufferendoffset=buf.getcurrentoffset() 
2876          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2877   
2878   
2879 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2880          'Reads this packet from the supplied buffer' 
2881          self._bufferstartoffset=buf.getcurrentoffset() 
2882          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2883          self.__field_index=UINT(**{'sizeinbytes': 2}) 
2884          self.__field_index.readfrombuffer(buf) 
2885          self.__field_bitmap=UINT(**{'sizeinbytes': 2}) 
2886          self.__field_bitmap.readfrombuffer(buf) 
2887          self._bufferendoffset=buf.getcurrentoffset() 
2888   
2889   
2890 -    def __getfield_index(self): 
2891          return self.__field_index.getvalue() 
2892   
2893 -    def __setfield_index(self, value): 
2894          if isinstance(value,UINT): 
2895              self.__field_index=value 
2896          else: 
2897              self.__field_index=UINT(value,**{'sizeinbytes': 2}) 
2898   
2899 -    def __delfield_index(self): del self.__field_index 
2900   
2901      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
2902   
2903 -    def __getfield_bitmap(self): 
2904          return self.__field_bitmap.getvalue() 
2905   
2906 -    def __setfield_bitmap(self, value): 
2907          if isinstance(value,UINT): 
2908              self.__field_bitmap=value 
2909          else: 
2910              self.__field_bitmap=UINT(value,**{'sizeinbytes': 2}) 
2911   
2912 -    def __delfield_bitmap(self): del self.__field_bitmap 
2913   
2914      bitmap=property(__getfield_bitmap, __setfield_bitmap, __delfield_bitmap, None) 
2915   
2916 -    def iscontainer(self): 
2917          return True 
2918   
2919 -    def containerelements(self): 
2920          yield ('index', self.__field_index, None) 
2921          yield ('bitmap', self.__field_bitmap, None) 
2922   
2923   
2924   
2925   
2926 -class JournalSpeeddial(BaseProtogenClass): 
2927      __fields=['index', 'speeddial', 'bitmap'] 
2928   
2929 -    def __init__(self, *args, **kwargs): 
2930          dict={} 
2931          # What was supplied to this function 
2932          dict.update(kwargs) 
2933          # Parent constructor 
2934          super(JournalSpeeddial,self).__init__(**dict) 
2935          if self.__class__ is JournalSpeeddial: 
2936              self._update(args,dict) 
2937   
2938   
2939 -    def getfields(self): 
2940          return self.__fields 
2941   
2942   
2943 -    def _update(self, args, kwargs): 
2944          super(JournalSpeeddial,self)._update(args,kwargs) 
2945          keys=kwargs.keys() 
2946          for key in keys: 
2947              if key in self.__fields: 
2948                  setattr(self, key, kwargs[key]) 
2949                  del kwargs[key] 
2950          # Were any unrecognized kwargs passed in? 
2951          if __debug__: 
2952              self._complainaboutunusedargs(JournalSpeeddial,kwargs) 
2953          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2954          # Make all P fields that haven't already been constructed 
2955   
2956   
2957 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2958          'Writes this packet to the supplied buffer' 
2959          self._bufferstartoffset=buf.getcurrentoffset() 
2960          self.__field_index.writetobuffer(buf) 
2961          self.__field_speeddial.writetobuffer(buf) 
2962          self.__field_bitmap.writetobuffer(buf) 
2963          self._bufferendoffset=buf.getcurrentoffset() 
2964          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2965   
2966   
2967 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2968          'Reads this packet from the supplied buffer' 
2969          self._bufferstartoffset=buf.getcurrentoffset() 
2970          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2971          self.__field_index=UINT(**{'sizeinbytes': 2}) 
2972          self.__field_index.readfrombuffer(buf) 
2973          self.__field_speeddial=UINT(**{'sizeinbytes': 2}) 
2974          self.__field_speeddial.readfrombuffer(buf) 
2975          self.__field_bitmap=UINT(**{'sizeinbytes': 2}) 
2976          self.__field_bitmap.readfrombuffer(buf) 
2977          self._bufferendoffset=buf.getcurrentoffset() 
2978   
2979   
2980 -    def __getfield_index(self): 
2981          return self.__field_index.getvalue() 
2982   
2983 -    def __setfield_index(self, value): 
2984          if isinstance(value,UINT): 
2985              self.__field_index=value 
2986          else: 
2987              self.__field_index=UINT(value,**{'sizeinbytes': 2}) 
2988   
2989 -    def __delfield_index(self): del self.__field_index 
2990   
2991      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
2992   
2993 -    def __getfield_speeddial(self): 
2994          return self.__field_speeddial.getvalue() 
2995   
2996 -    def __setfield_speeddial(self, value): 
2997          if isinstance(value,UINT): 
2998              self.__field_speeddial=value 
2999          else: 
3000              self.__field_speeddial=UINT(value,**{'sizeinbytes': 2}) 
3001   
3002 -    def __delfield_speeddial(self): del self.__field_speeddial 
3003   
3004      speeddial=property(__getfield_speeddial, __setfield_speeddial, __delfield_speeddial, None) 
3005   
3006 -    def __getfield_bitmap(self): 
3007          return self.__field_bitmap.getvalue() 
3008   
3009 -    def __setfield_bitmap(self, value): 
3010          if isinstance(value,UINT): 
3011              self.__field_bitmap=value 
3012          else: 
3013              self.__field_bitmap=UINT(value,**{'sizeinbytes': 2}) 
3014   
3015 -    def __delfield_bitmap(self): del self.__field_bitmap 
3016   
3017      bitmap=property(__getfield_bitmap, __setfield_bitmap, __delfield_bitmap, None) 
3018   
3019 -    def iscontainer(self): 
3020          return True 
3021   
3022 -    def containerelements(self): 
3023          yield ('index', self.__field_index, None) 
3024          yield ('speeddial', self.__field_speeddial, None) 
3025          yield ('bitmap', self.__field_bitmap, None) 
3026   
3027   
3028   
3029   
3030 -class JournalEntry(BaseProtogenClass): 
3031      __fields=['number_info', 'speeddial_info', 'index', 'data1', 'previndex', 'home', 'nohome', 'work', 'nowork', 'cell', 'nocell', 'data2', 'fax', 'nofax', 'cell2', 'nocell2', 'homesd', 'nohomesd', 'worksd', 'noworksd', 'cellsd', 'nocellsd', 'data3', 'faxsd', 'nofaxsd', 'cell2sd', 'nocell2sd', 'previndex2', 'previndex3', 'data4', 'email', 'email2', 'wallpaper'] 
3032   
3033 -    def __init__(self, *args, **kwargs): 
3034          dict={} 
3035          # What was supplied to this function 
3036          dict.update(kwargs) 
3037          # Parent constructor 
3038          super(JournalEntry,self).__init__(**dict) 
3039          if self.__class__ is JournalEntry: 
3040              self._update(args,dict) 
3041   
3042   
3043 -    def getfields(self): 
3044          return self.__fields 
3045   
3046   
3047 -    def _update(self, args, kwargs): 
3048          super(JournalEntry,self)._update(args,kwargs) 
3049          keys=kwargs.keys() 
3050          for key in keys: 
3051              if key in self.__fields: 
3052                  setattr(self, key, kwargs[key]) 
3053                  del kwargs[key] 
3054          # Were any unrecognized kwargs passed in? 
3055          if __debug__: 
3056              self._complainaboutunusedargs(JournalEntry,kwargs) 
3057          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
3058          # Make all P fields that haven't already been constructed 
3059          try: self.__field_number_info 
3060          except: 
3061              self.__field_number_info=UINT(**{ 'default': 0 }) 
3062          try: self.__field_speeddial_info 
3063          except: 
3064              self.__field_speeddial_info=UINT(**{ 'default': 0 }) 
3065   
3066   
3067 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3068          'Writes this packet to the supplied buffer' 
3069          self._bufferstartoffset=buf.getcurrentoffset() 
3070          self.__field_index.writetobuffer(buf) 
3071          try: self.__field_data1 
3072          except: 
3073              self.__field_data1=DATA(**{'sizeinbytes': 1,  'default': '\x00' }) 
3074          self.__field_data1.writetobuffer(buf) 
3075          try: self.__field_previndex 
3076          except: 
3077              self.__field_previndex=UINT(**{'sizeinbytes': 2,  'default': self.index-1 }) 
3078          self.__field_previndex.writetobuffer(buf) 
3079          if self.number_info & PB_FLG_HOME: 
3080              self.__field_home.writetobuffer(buf) 
3081          else: 
3082              try: self.__field_nohome 
3083              except: 
3084                  self.__field_nohome=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3085              self.__field_nohome.writetobuffer(buf) 
3086          if self.number_info & PB_FLG_WORK: 
3087              self.__field_work.writetobuffer(buf) 
3088          else: 
3089              try: self.__field_nowork 
3090              except: 
3091                  self.__field_nowork=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3092              self.__field_nowork.writetobuffer(buf) 
3093          if self.number_info & PB_FLG_CELL: 
3094              self.__field_cell.writetobuffer(buf) 
3095          else: 
3096              try: self.__field_nocell 
3097              except: 
3098                  self.__field_nocell=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3099              self.__field_nocell.writetobuffer(buf) 
3100          try: self.__field_data2 
3101          except: 
3102              self.__field_data2=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3103          self.__field_data2.writetobuffer(buf) 
3104          if self.number_info & PB_FLG_FAX: 
3105              self.__field_fax.writetobuffer(buf) 
3106          else: 
3107              try: self.__field_nofax 
3108              except: 
3109                  self.__field_nofax=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3110              self.__field_nofax.writetobuffer(buf) 
3111          if self.number_info&PB_FLG_CELL2: 
3112              self.__field_cell2.writetobuffer(buf) 
3113          else: 
3114              try: self.__field_nocell2 
3115              except: 
3116                  self.__field_nocell2=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3117              self.__field_nocell2.writetobuffer(buf) 
3118          if self.speeddial_info & PB_FLG_HOME: 
3119              self.__field_homesd.writetobuffer(buf) 
3120          else: 
3121              try: self.__field_nohomesd 
3122              except: 
3123                  self.__field_nohomesd=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3124              self.__field_nohomesd.writetobuffer(buf) 
3125          if self.speeddial_info & PB_FLG_WORK: 
3126              self.__field_worksd.writetobuffer(buf) 
3127          else: 
3128              try: self.__field_noworksd 
3129              except: 
3130                  self.__field_noworksd=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3131              self.__field_noworksd.writetobuffer(buf) 
3132          if self.speeddial_info&PB_FLG_CELL: 
3133              self.__field_cellsd.writetobuffer(buf) 
3134          else: 
3135              try: self.__field_nocellsd 
3136              except: 
3137                  self.__field_nocellsd=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3138              self.__field_nocellsd.writetobuffer(buf) 
3139          try: self.__field_data3 
3140          except: 
3141              self.__field_data3=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3142          self.__field_data3.writetobuffer(buf) 
3143          if self.speeddial_info&PB_FLG_FAX: 
3144              self.__field_faxsd.writetobuffer(buf) 
3145          else: 
3146              try: self.__field_nofaxsd 
3147              except: 
3148                  self.__field_nofaxsd=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3149              self.__field_nofaxsd.writetobuffer(buf) 
3150          if self.speeddial_info&PB_FLG_CELL2: 
3151              self.__field_cell2sd.writetobuffer(buf) 
3152          else: 
3153              try: self.__field_nocell2sd 
3154              except: 
3155                  self.__field_nocell2sd=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3156              self.__field_nocell2sd.writetobuffer(buf) 
3157          try: self.__field_previndex2 
3158          except: 
3159              self.__field_previndex2=UINT(**{'sizeinbytes': 2,  'default': self.previndex }) 
3160          self.__field_previndex2.writetobuffer(buf) 
3161          try: self.__field_previndex3 
3162          except: 
3163              self.__field_previndex3=UINT(**{'sizeinbytes': 2,  'default': self.previndex }) 
3164          self.__field_previndex3.writetobuffer(buf) 
3165          try: self.__field_data4 
3166          except: 
3167              self.__field_data4=DATA(**{'sizeinbytes': 4,  'default': '\x10\x00\x0C\x04' }) 
3168          self.__field_data4.writetobuffer(buf) 
3169          try: self.__field_email 
3170          except: 
3171              self.__field_email=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3172          self.__field_email.writetobuffer(buf) 
3173          try: self.__field_email2 
3174          except: 
3175              self.__field_email2=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3176          self.__field_email2.writetobuffer(buf) 
3177          try: self.__field_wallpaper 
3178          except: 
3179              self.__field_wallpaper=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3180          self.__field_wallpaper.writetobuffer(buf) 
3181          self._bufferendoffset=buf.getcurrentoffset() 
3182          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3183   
3184   
3185 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3186          'Reads this packet from the supplied buffer' 
3187          self._bufferstartoffset=buf.getcurrentoffset() 
3188          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3189          self.__field_index=UINT(**{'sizeinbytes': 2}) 
3190          self.__field_index.readfrombuffer(buf) 
3191          self.__field_data1=DATA(**{'sizeinbytes': 1,  'default': '\x00' }) 
3192          self.__field_data1.readfrombuffer(buf) 
3193          self.__field_previndex=UINT(**{'sizeinbytes': 2,  'default': self.index-1 }) 
3194          self.__field_previndex.readfrombuffer(buf) 
3195          if self.number_info & PB_FLG_HOME: 
3196              self.__field_home=JournalNumber() 
3197              self.__field_home.readfrombuffer(buf) 
3198          else: 
3199              self.__field_nohome=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3200              self.__field_nohome.readfrombuffer(buf) 
3201          if self.number_info & PB_FLG_WORK: 
3202              self.__field_work=JournalNumber() 
3203              self.__field_work.readfrombuffer(buf) 
3204          else: 
3205              self.__field_nowork=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3206              self.__field_nowork.readfrombuffer(buf) 
3207          if self.number_info & PB_FLG_CELL: 
3208              self.__field_cell=JournalNumber() 
3209              self.__field_cell.readfrombuffer(buf) 
3210          else: 
3211              self.__field_nocell=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3212              self.__field_nocell.readfrombuffer(buf) 
3213          self.__field_data2=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3214          self.__field_data2.readfrombuffer(buf) 
3215          if self.number_info & PB_FLG_FAX: 
3216              self.__field_fax=JournalNumber() 
3217              self.__field_fax.readfrombuffer(buf) 
3218          else: 
3219              self.__field_nofax=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3220              self.__field_nofax.readfrombuffer(buf) 
3221          if self.number_info&PB_FLG_CELL2: 
3222              self.__field_cell2=JournalNumber() 
3223              self.__field_cell2.readfrombuffer(buf) 
3224          else: 
3225              self.__field_nocell2=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3226              self.__field_nocell2.readfrombuffer(buf) 
3227          if self.speeddial_info & PB_FLG_HOME: 
3228              self.__field_homesd=JournalSpeeddial() 
3229              self.__field_homesd.readfrombuffer(buf) 
3230          else: 
3231              self.__field_nohomesd=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3232              self.__field_nohomesd.readfrombuffer(buf) 
3233          if self.speeddial_info & PB_FLG_WORK: 
3234              self.__field_worksd=JournalSpeeddial() 
3235              self.__field_worksd.readfrombuffer(buf) 
3236          else: 
3237              self.__field_noworksd=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3238              self.__field_noworksd.readfrombuffer(buf) 
3239          if self.speeddial_info&PB_FLG_CELL: 
3240              self.__field_cellsd=JournalSpeeddial() 
3241              self.__field_cellsd.readfrombuffer(buf) 
3242          else: 
3243              self.__field_nocellsd=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3244              self.__field_nocellsd.readfrombuffer(buf) 
3245          self.__field_data3=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3246          self.__field_data3.readfrombuffer(buf) 
3247          if self.speeddial_info&PB_FLG_FAX: 
3248              self.__field_faxsd=JournalSpeeddial() 
3249              self.__field_faxsd.readfrombuffer(buf) 
3250          else: 
3251              self.__field_nofaxsd=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3252              self.__field_nofaxsd.readfrombuffer(buf) 
3253          if self.speeddial_info&PB_FLG_CELL2: 
3254              self.__field_cell2sd=JournalSpeeddial() 
3255              self.__field_cell2sd.readfrombuffer(buf) 
3256          else: 
3257              self.__field_nocell2sd=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3258              self.__field_nocell2sd.readfrombuffer(buf) 
3259          self.__field_previndex2=UINT(**{'sizeinbytes': 2,  'default': self.previndex }) 
3260          self.__field_previndex2.readfrombuffer(buf) 
3261          self.__field_previndex3=UINT(**{'sizeinbytes': 2,  'default': self.previndex }) 
3262          self.__field_previndex3.readfrombuffer(buf) 
3263          self.__field_data4=DATA(**{'sizeinbytes': 4,  'default': '\x10\x00\x0C\x04' }) 
3264          self.__field_data4.readfrombuffer(buf) 
3265          self.__field_email=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3266          self.__field_email.readfrombuffer(buf) 
3267          self.__field_email2=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3268          self.__field_email2.readfrombuffer(buf) 
3269          self.__field_wallpaper=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3270          self.__field_wallpaper.readfrombuffer(buf) 
3271          self._bufferendoffset=buf.getcurrentoffset() 
3272   
3273   
3274 -    def __getfield_number_info(self): 
3275          try: self.__field_number_info 
3276          except: 
3277              self.__field_number_info=UINT(**{ 'default': 0 }) 
3278          return self.__field_number_info.getvalue() 
3279   
3280 -    def __setfield_number_info(self, value): 
3281          if isinstance(value,UINT): 
3282              self.__field_number_info=value 
3283          else: 
3284              self.__field_number_info=UINT(value,**{ 'default': 0 }) 
3285   
3286 -    def __delfield_number_info(self): del self.__field_number_info 
3287   
3288      number_info=property(__getfield_number_info, __setfield_number_info, __delfield_number_info, None) 
3289   
3290 -    def __getfield_speeddial_info(self): 
3291          try: self.__field_speeddial_info 
3292          except: 
3293              self.__field_speeddial_info=UINT(**{ 'default': 0 }) 
3294          return self.__field_speeddial_info.getvalue() 
3295   
3296 -    def __setfield_speeddial_info(self, value): 
3297          if isinstance(value,UINT): 
3298              self.__field_speeddial_info=value 
3299          else: 
3300              self.__field_speeddial_info=UINT(value,**{ 'default': 0 }) 
3301   
3302 -    def __delfield_speeddial_info(self): del self.__field_speeddial_info 
3303   
3304      speeddial_info=property(__getfield_speeddial_info, __setfield_speeddial_info, __delfield_speeddial_info, None) 
3305   
3306 -    def __getfield_index(self): 
3307          return self.__field_index.getvalue() 
3308   
3309 -    def __setfield_index(self, value): 
3310          if isinstance(value,UINT): 
3311              self.__field_index=value 
3312          else: 
3313              self.__field_index=UINT(value,**{'sizeinbytes': 2}) 
3314   
3315 -    def __delfield_index(self): del self.__field_index 
3316   
3317      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
3318   
3319 -    def __getfield_data1(self): 
3320          try: self.__field_data1 
3321          except: 
3322              self.__field_data1=DATA(**{'sizeinbytes': 1,  'default': '\x00' }) 
3323          return self.__field_data1.getvalue() 
3324   
3325 -    def __setfield_data1(self, value): 
3326          if isinstance(value,DATA): 
3327              self.__field_data1=value 
3328          else: 
3329              self.__field_data1=DATA(value,**{'sizeinbytes': 1,  'default': '\x00' }) 
3330   
3331 -    def __delfield_data1(self): del self.__field_data1 
3332   
3333      data1=property(__getfield_data1, __setfield_data1, __delfield_data1, None) 
3334   
3335 -    def __getfield_previndex(self): 
3336          try: self.__field_previndex 
3337          except: 
3338              self.__field_previndex=UINT(**{'sizeinbytes': 2,  'default': self.index-1 }) 
3339          return self.__field_previndex.getvalue() 
3340   
3341 -    def __setfield_previndex(self, value): 
3342          if isinstance(value,UINT): 
3343              self.__field_previndex=value 
3344          else: 
3345              self.__field_previndex=UINT(value,**{'sizeinbytes': 2,  'default': self.index-1 }) 
3346   
3347 -    def __delfield_previndex(self): del self.__field_previndex 
3348   
3349      previndex=property(__getfield_previndex, __setfield_previndex, __delfield_previndex, None) 
3350   
3351 -    def __getfield_home(self): 
3352          return self.__field_home.getvalue() 
3353   
3354 -    def __setfield_home(self, value): 
3355          if isinstance(value,JournalNumber): 
3356              self.__field_home=value 
3357          else: 
3358              self.__field_home=JournalNumber(value,) 
3359   
3360 -    def __delfield_home(self): del self.__field_home 
3361   
3362      home=property(__getfield_home, __setfield_home, __delfield_home, None) 
3363   
3364 -    def __getfield_nohome(self): 
3365          try: self.__field_nohome 
3366          except: 
3367              self.__field_nohome=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3368          return self.__field_nohome.getvalue() 
3369   
3370 -    def __setfield_nohome(self, value): 
3371          if isinstance(value,UINT): 
3372              self.__field_nohome=value 
3373          else: 
3374              self.__field_nohome=UINT(value,**{'sizeinbytes': 2,  'default': 0xffff }) 
3375   
3376 -    def __delfield_nohome(self): del self.__field_nohome 
3377   
3378      nohome=property(__getfield_nohome, __setfield_nohome, __delfield_nohome, None) 
3379   
3380 -    def __getfield_work(self): 
3381          return self.__field_work.getvalue() 
3382   
3383 -    def __setfield_work(self, value): 
3384          if isinstance(value,JournalNumber): 
3385              self.__field_work=value 
3386          else: 
3387              self.__field_work=JournalNumber(value,) 
3388   
3389 -    def __delfield_work(self): del self.__field_work 
3390   
3391      work=property(__getfield_work, __setfield_work, __delfield_work, None) 
3392   
3393 -    def __getfield_nowork(self): 
3394          try: self.__field_nowork 
3395          except: 
3396              self.__field_nowork=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3397          return self.__field_nowork.getvalue() 
3398   
3399 -    def __setfield_nowork(self, value): 
3400          if isinstance(value,UINT): 
3401              self.__field_nowork=value 
3402          else: 
3403              self.__field_nowork=UINT(value,**{'sizeinbytes': 2,  'default': 0xffff }) 
3404   
3405 -    def __delfield_nowork(self): del self.__field_nowork 
3406   
3407      nowork=property(__getfield_nowork, __setfield_nowork, __delfield_nowork, None) 
3408   
3409 -    def __getfield_cell(self): 
3410          return self.__field_cell.getvalue() 
3411   
3412 -    def __setfield_cell(self, value): 
3413          if isinstance(value,JournalNumber): 
3414              self.__field_cell=value 
3415          else: 
3416              self.__field_cell=JournalNumber(value,) 
3417   
3418 -    def __delfield_cell(self): del self.__field_cell 
3419   
3420      cell=property(__getfield_cell, __setfield_cell, __delfield_cell, None) 
3421   
3422 -    def __getfield_nocell(self): 
3423          try: self.__field_nocell 
3424          except: 
3425              self.__field_nocell=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3426          return self.__field_nocell.getvalue() 
3427   
3428 -    def __setfield_nocell(self, value): 
3429          if isinstance(value,UINT): 
3430              self.__field_nocell=value 
3431          else: 
3432              self.__field_nocell=UINT(value,**{'sizeinbytes': 2,  'default': 0xffff }) 
3433   
3434 -    def __delfield_nocell(self): del self.__field_nocell 
3435   
3436      nocell=property(__getfield_nocell, __setfield_nocell, __delfield_nocell, None) 
3437   
3438 -    def __getfield_data2(self): 
3439          try: self.__field_data2 
3440          except: 
3441              self.__field_data2=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3442          return self.__field_data2.getvalue() 
3443   
3444 -    def __setfield_data2(self, value): 
3445          if isinstance(value,UINT): 
3446              self.__field_data2=value 
3447          else: 
3448              self.__field_data2=UINT(value,**{'sizeinbytes': 2,  'default': 0xffff }) 
3449   
3450 -    def __delfield_data2(self): del self.__field_data2 
3451   
3452      data2=property(__getfield_data2, __setfield_data2, __delfield_data2, None) 
3453   
3454 -    def __getfield_fax(self): 
3455          return self.__field_fax.getvalue() 
3456   
3457 -    def __setfield_fax(self, value): 
3458          if isinstance(value,JournalNumber): 
3459              self.__field_fax=value 
3460          else: 
3461              self.__field_fax=JournalNumber(value,) 
3462   
3463 -    def __delfield_fax(self): del self.__field_fax 
3464   
3465      fax=property(__getfield_fax, __setfield_fax, __delfield_fax, None) 
3466   
3467 -    def __getfield_nofax(self): 
3468          try: self.__field_nofax 
3469          except: 
3470              self.__field_nofax=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3471          return self.__field_nofax.getvalue() 
3472   
3473 -    def __setfield_nofax(self, value): 
3474          if isinstance(value,UINT): 
3475              self.__field_nofax=value 
3476          else: 
3477              self.__field_nofax=UINT(value,**{'sizeinbytes': 2,  'default': 0xffff }) 
3478   
3479 -    def __delfield_nofax(self): del self.__field_nofax 
3480   
3481      nofax=property(__getfield_nofax, __setfield_nofax, __delfield_nofax, None) 
3482   
3483 -    def __getfield_cell2(self): 
3484          return self.__field_cell2.getvalue() 
3485   
3486 -    def __setfield_cell2(self, value): 
3487          if isinstance(value,JournalNumber): 
3488              self.__field_cell2=value 
3489          else: 
3490              self.__field_cell2=JournalNumber(value,) 
3491   
3492 -    def __delfield_cell2(self): del self.__field_cell2 
3493   
3494      cell2=property(__getfield_cell2, __setfield_cell2, __delfield_cell2, None) 
3495   
3496 -    def __getfield_nocell2(self): 
3497          try: self.__field_nocell2 
3498          except: 
3499              self.__field_nocell2=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3500          return self.__field_nocell2.getvalue() 
3501   
3502 -    def __setfield_nocell2(self, value): 
3503          if isinstance(value,UINT): 
3504              self.__field_nocell2=value 
3505          else: 
3506              self.__field_nocell2=UINT(value,**{'sizeinbytes': 2,  'default': 0xffff }) 
3507   
3508 -    def __delfield_nocell2(self): del self.__field_nocell2 
3509   
3510      nocell2=property(__getfield_nocell2, __setfield_nocell2, __delfield_nocell2, None) 
3511   
3512 -    def __getfield_homesd(self): 
3513          return self.__field_homesd.getvalue() 
3514   
3515 -    def __setfield_homesd(self, value): 
3516          if isinstance(value,JournalSpeeddial): 
3517              self.__field_homesd=value 
3518          else: 
3519              self.__field_homesd=JournalSpeeddial(value,) 
3520   
3521 -    def __delfield_homesd(self): del self.__field_homesd 
3522   
3523      homesd=property(__getfield_homesd, __setfield_homesd, __delfield_homesd, None) 
3524   
3525 -    def __getfield_nohomesd(self): 
3526          try: self.__field_nohomesd 
3527          except: 
3528              self.__field_nohomesd=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3529          return self.__field_nohomesd.getvalue() 
3530   
3531 -    def __setfield_nohomesd(self, value): 
3532          if isinstance(value,UINT): 
3533              self.__field_nohomesd=value 
3534          else: 
3535              self.__field_nohomesd=UINT(value,**{'sizeinbytes': 2,  'default': 0xffff }) 
3536   
3537 -    def __delfield_nohomesd(self): del self.__field_nohomesd 
3538   
3539      nohomesd=property(__getfield_nohomesd, __setfield_nohomesd, __delfield_nohomesd, None) 
3540   
3541 -    def __getfield_worksd(self): 
3542          return self.__field_worksd.getvalue() 
3543   
3544 -    def __setfield_worksd(self, value): 
3545          if isinstance(value,JournalSpeeddial): 
3546              self.__field_worksd=value 
3547          else: 
3548              self.__field_worksd=JournalSpeeddial(value,) 
3549   
3550 -    def __delfield_worksd(self): del self.__field_worksd 
3551   
3552      worksd=property(__getfield_worksd, __setfield_worksd, __delfield_worksd, None) 
3553   
3554 -    def __getfield_noworksd(self): 
3555          try: self.__field_noworksd 
3556          except: 
3557              self.__field_noworksd=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3558          return self.__field_noworksd.getvalue() 
3559   
3560 -    def __setfield_noworksd(self, value): 
3561          if isinstance(value,UINT): 
3562              self.__field_noworksd=value 
3563          else: 
3564              self.__field_noworksd=UINT(value,**{'sizeinbytes': 2,  'default': 0xffff }) 
3565   
3566 -    def __delfield_noworksd(self): del self.__field_noworksd 
3567   
3568      noworksd=property(__getfield_noworksd, __setfield_noworksd, __delfield_noworksd, None) 
3569   
3570 -    def __getfield_cellsd(self): 
3571          return self.__field_cellsd.getvalue() 
3572   
3573 -    def __setfield_cellsd(self, value): 
3574          if isinstance(value,JournalSpeeddial): 
3575              self.__field_cellsd=value 
3576          else: 
3577              self.__field_cellsd=JournalSpeeddial(value,) 
3578   
3579 -    def __delfield_cellsd(self): del self.__field_cellsd 
3580   
3581      cellsd=property(__getfield_cellsd, __setfield_cellsd, __delfield_cellsd, None) 
3582   
3583 -    def __getfield_nocellsd(self): 
3584          try: self.__field_nocellsd 
3585          except: 
3586              self.__field_nocellsd=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3587          return self.__field_nocellsd.getvalue() 
3588   
3589 -    def __setfield_nocellsd(self, value): 
3590          if isinstance(value,UINT): 
3591              self.__field_nocellsd=value 
3592          else: 
3593              self.__field_nocellsd=UINT(value,**{'sizeinbytes': 2,  'default': 0xffff }) 
3594   
3595 -    def __delfield_nocellsd(self): del self.__field_nocellsd 
3596   
3597      nocellsd=property(__getfield_nocellsd, __setfield_nocellsd, __delfield_nocellsd, None) 
3598   
3599 -    def __getfield_data3(self): 
3600          try: self.__field_data3 
3601          except: 
3602              self.__field_data3=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3603          return self.__field_data3.getvalue() 
3604   
3605 -    def __setfield_data3(self, value): 
3606          if isinstance(value,UINT): 
3607              self.__field_data3=value 
3608          else: 
3609              self.__field_data3=UINT(value,**{'sizeinbytes': 2,  'default': 0xffff }) 
3610   
3611 -    def __delfield_data3(self): del self.__field_data3 
3612   
3613      data3=property(__getfield_data3, __setfield_data3, __delfield_data3, None) 
3614   
3615 -    def __getfield_faxsd(self): 
3616          return self.__field_faxsd.getvalue() 
3617   
3618 -    def __setfield_faxsd(self, value): 
3619          if isinstance(value,JournalSpeeddial): 
3620              self.__field_faxsd=value 
3621          else: 
3622              self.__field_faxsd=JournalSpeeddial(value,) 
3623   
3624 -    def __delfield_faxsd(self): del self.__field_faxsd 
3625   
3626      faxsd=property(__getfield_faxsd, __setfield_faxsd, __delfield_faxsd, None) 
3627   
3628 -    def __getfield_nofaxsd(self): 
3629          try: self.__field_nofaxsd 
3630          except: 
3631              self.__field_nofaxsd=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3632          return self.__field_nofaxsd.getvalue() 
3633   
3634 -    def __setfield_nofaxsd(self, value): 
3635          if isinstance(value,UINT): 
3636              self.__field_nofaxsd=value 
3637          else: 
3638              self.__field_nofaxsd=UINT(value,**{'sizeinbytes': 2,  'default': 0xffff }) 
3639   
3640 -    def __delfield_nofaxsd(self): del self.__field_nofaxsd 
3641   
3642      nofaxsd=property(__getfield_nofaxsd, __setfield_nofaxsd, __delfield_nofaxsd, None) 
3643   
3644 -    def __getfield_cell2sd(self): 
3645          return self.__field_cell2sd.getvalue() 
3646   
3647 -    def __setfield_cell2sd(self, value): 
3648          if isinstance(value,JournalSpeeddial): 
3649              self.__field_cell2sd=value 
3650          else: 
3651              self.__field_cell2sd=JournalSpeeddial(value,) 
3652   
3653 -    def __delfield_cell2sd(self): del self.__field_cell2sd 
3654   
3655      cell2sd=property(__getfield_cell2sd, __setfield_cell2sd, __delfield_cell2sd, None) 
3656   
3657 -    def __getfield_nocell2sd(self): 
3658          try: self.__field_nocell2sd 
3659          except: 
3660              self.__field_nocell2sd=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3661          return self.__field_nocell2sd.getvalue() 
3662   
3663 -    def __setfield_nocell2sd(self, value): 
3664          if isinstance(value,UINT): 
3665              self.__field_nocell2sd=value 
3666          else: 
3667              self.__field_nocell2sd=UINT(value,**{'sizeinbytes': 2,  'default': 0xffff }) 
3668   
3669 -    def __delfield_nocell2sd(self): del self.__field_nocell2sd 
3670   
3671      nocell2sd=property(__getfield_nocell2sd, __setfield_nocell2sd, __delfield_nocell2sd, None) 
3672   
3673 -    def __getfield_previndex2(self): 
3674          try: self.__field_previndex2 
3675          except: 
3676              self.__field_previndex2=UINT(**{'sizeinbytes': 2,  'default': self.previndex }) 
3677          return self.__field_previndex2.getvalue() 
3678   
3679 -    def __setfield_previndex2(self, value): 
3680          if isinstance(value,UINT): 
3681              self.__field_previndex2=value 
3682          else: 
3683              self.__field_previndex2=UINT(value,**{'sizeinbytes': 2,  'default': self.previndex }) 
3684   
3685 -    def __delfield_previndex2(self): del self.__field_previndex2 
3686   
3687      previndex2=property(__getfield_previndex2, __setfield_previndex2, __delfield_previndex2, None) 
3688   
3689 -    def __getfield_previndex3(self): 
3690          try: self.__field_previndex3 
3691          except: 
3692              self.__field_previndex3=UINT(**{'sizeinbytes': 2,  'default': self.previndex }) 
3693          return self.__field_previndex3.getvalue() 
3694   
3695 -    def __setfield_previndex3(self, value): 
3696          if isinstance(value,UINT): 
3697              self.__field_previndex3=value 
3698          else: 
3699              self.__field_previndex3=UINT(value,**{'sizeinbytes': 2,  'default': self.previndex }) 
3700   
3701 -    def __delfield_previndex3(self): del self.__field_previndex3 
3702   
3703      previndex3=property(__getfield_previndex3, __setfield_previndex3, __delfield_previndex3, None) 
3704   
3705 -    def __getfield_data4(self): 
3706          try: self.__field_data4 
3707          except: 
3708              self.__field_data4=DATA(**{'sizeinbytes': 4,  'default': '\x10\x00\x0C\x04' }) 
3709          return self.__field_data4.getvalue() 
3710   
3711 -    def __setfield_data4(self, value): 
3712          if isinstance(value,DATA): 
3713              self.__field_data4=value 
3714          else: 
3715              self.__field_data4=DATA(value,**{'sizeinbytes': 4,  'default': '\x10\x00\x0C\x04' }) 
3716   
3717 -    def __delfield_data4(self): del self.__field_data4 
3718   
3719      data4=property(__getfield_data4, __setfield_data4, __delfield_data4, None) 
3720   
3721 -    def __getfield_email(self): 
3722          try: self.__field_email 
3723          except: 
3724              self.__field_email=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3725          return self.__field_email.getvalue() 
3726   
3727 -    def __setfield_email(self, value): 
3728          if isinstance(value,UINT): 
3729              self.__field_email=value 
3730          else: 
3731              self.__field_email=UINT(value,**{'sizeinbytes': 2,  'default': 0xffff }) 
3732   
3733 -    def __delfield_email(self): del self.__field_email 
3734   
3735      email=property(__getfield_email, __setfield_email, __delfield_email, None) 
3736   
3737 -    def __getfield_email2(self): 
3738          try: self.__field_email2 
3739          except: 
3740              self.__field_email2=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3741          return self.__field_email2.getvalue() 
3742   
3743 -    def __setfield_email2(self, value): 
3744          if isinstance(value,UINT): 
3745              self.__field_email2=value 
3746          else: 
3747              self.__field_email2=UINT(value,**{'sizeinbytes': 2,  'default': 0xffff }) 
3748   
3749 -    def __delfield_email2(self): del self.__field_email2 
3750   
3751      email2=property(__getfield_email2, __setfield_email2, __delfield_email2, None) 
3752   
3753 -    def __getfield_wallpaper(self): 
3754          try: self.__field_wallpaper 
3755          except: 
3756              self.__field_wallpaper=UINT(**{'sizeinbytes': 2,  'default': 0xffff }) 
3757          return self.__field_wallpaper.getvalue() 
3758   
3759 -    def __setfield_wallpaper(self, value): 
3760          if isinstance(value,UINT): 
3761              self.__field_wallpaper=value 
3762          else: 
3763              self.__field_wallpaper=UINT(value,**{'sizeinbytes': 2,  'default': 0xffff }) 
3764   
3765 -    def __delfield_wallpaper(self): del self.__field_wallpaper 
3766   
3767      wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None) 
3768   
3769 -    def iscontainer(self): 
3770          return True 
3771   
3772 -    def containerelements(self): 
3773          yield ('number_info', self.__field_number_info, None) 
3774          yield ('speeddial_info', self.__field_speeddial_info, None) 
3775          yield ('index', self.__field_index, None) 
3776          yield ('data1', self.__field_data1, None) 
3777          yield ('previndex', self.__field_previndex, None) 
3778          if self.number_info & PB_FLG_HOME: 
3779              yield ('home', self.__field_home, None) 
3780          else: 
3781              yield ('nohome', self.__field_nohome, None) 
3782          if self.number_info & PB_FLG_WORK: 
3783              yield ('work', self.__field_work, None) 
3784          else: 
3785              yield ('nowork', self.__field_nowork, None) 
3786          if self.number_info & PB_FLG_CELL: 
3787              yield ('cell', self.__field_cell, None) 
3788          else: 
3789              yield ('nocell', self.__field_nocell, None) 
3790          yield ('data2', self.__field_data2, None) 
3791          if self.number_info & PB_FLG_FAX: 
3792              yield ('fax', self.__field_fax, None) 
3793          else: 
3794              yield ('nofax', self.__field_nofax, None) 
3795          if self.number_info&PB_FLG_CELL2: 
3796              yield ('cell2', self.__field_cell2, None) 
3797          else: 
3798              yield ('nocell2', self.__field_nocell2, None) 
3799          if self.speeddial_info & PB_FLG_HOME: 
3800              yield ('homesd', self.__field_homesd, None) 
3801          else: 
3802              yield ('nohomesd', self.__field_nohomesd, None) 
3803          if self.speeddial_info & PB_FLG_WORK: 
3804              yield ('worksd', self.__field_worksd, None) 
3805          else: 
3806              yield ('noworksd', self.__field_noworksd, None) 
3807          if self.speeddial_info&PB_FLG_CELL: 
3808              yield ('cellsd', self.__field_cellsd, None) 
3809          else: 
3810              yield ('nocellsd', self.__field_nocellsd, None) 
3811          yield ('data3', self.__field_data3, None) 
3812          if self.speeddial_info&PB_FLG_FAX: 
3813              yield ('faxsd', self.__field_faxsd, None) 
3814          else: 
3815              yield ('nofaxsd', self.__field_nofaxsd, None) 
3816          if self.speeddial_info&PB_FLG_CELL2: 
3817              yield ('cell2sd', self.__field_cell2sd, None) 
3818          else: 
3819              yield ('nocell2sd', self.__field_nocell2sd, None) 
3820          yield ('previndex2', self.__field_previndex2, None) 
3821          yield ('previndex3', self.__field_previndex3, None) 
3822          yield ('data4', self.__field_data4, None) 
3823          yield ('email', self.__field_email, None) 
3824          yield ('email2', self.__field_email2, None) 
3825          yield ('wallpaper', self.__field_wallpaper, None) 
3826   
3827   
3828   
3829   
3830 -class JournalRec(BaseProtogenClass): 
3831      __fields=['command', 'blocklen', 'entry'] 
3832   
3833 -    def __init__(self, *args, **kwargs): 
3834          dict={} 
3835          # What was supplied to this function 
3836          dict.update(kwargs) 
3837          # Parent constructor 
3838          super(JournalRec,self).__init__(**dict) 
3839          if self.__class__ is JournalRec: 
3840              self._update(args,dict) 
3841   
3842   
3843 -    def getfields(self): 
3844          return self.__fields 
3845   
3846   
3847 -    def _update(self, args, kwargs): 
3848          super(JournalRec,self)._update(args,kwargs) 
3849          keys=kwargs.keys() 
3850          for key in keys: 
3851              if key in self.__fields: 
3852                  setattr(self, key, kwargs[key]) 
3853                  del kwargs[key] 
3854          # Were any unrecognized kwargs passed in? 
3855          if __debug__: 
3856              self._complainaboutunusedargs(JournalRec,kwargs) 
3857          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
3858          # Make all P fields that haven't already been constructed 
3859   
3860   
3861 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3862          'Writes this packet to the supplied buffer' 
3863          self._bufferstartoffset=buf.getcurrentoffset() 
3864          try: self.__field_command 
3865          except: 
3866              self.__field_command=UINT(**{'sizeinbytes': 1,  'default': 1 }) 
3867          self.__field_command.writetobuffer(buf) 
3868          try: self.__field_blocklen 
3869          except: 
3870              self.__field_blocklen=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
3871          self.__field_blocklen.writetobuffer(buf) 
3872          self.__field_entry.writetobuffer(buf) 
3873          self._bufferendoffset=buf.getcurrentoffset() 
3874          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3875   
3876   
3877 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3878          'Reads this packet from the supplied buffer' 
3879          self._bufferstartoffset=buf.getcurrentoffset() 
3880          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3881          self.__field_command=UINT(**{'sizeinbytes': 1,  'default': 1 }) 
3882          self.__field_command.readfrombuffer(buf) 
3883          self.__field_blocklen=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
3884          self.__field_blocklen.readfrombuffer(buf) 
3885          self.__field_entry=JournalEntry() 
3886          self.__field_entry.readfrombuffer(buf) 
3887          self._bufferendoffset=buf.getcurrentoffset() 
3888   
3889   
3890 -    def __getfield_command(self): 
3891          try: self.__field_command 
3892          except: 
3893              self.__field_command=UINT(**{'sizeinbytes': 1,  'default': 1 }) 
3894          return self.__field_command.getvalue() 
3895   
3896 -    def __setfield_command(self, value): 
3897          if isinstance(value,UINT): 
3898              self.__field_command=value 
3899          else: 
3900              self.__field_command=UINT(value,**{'sizeinbytes': 1,  'default': 1 }) 
3901   
3902 -    def __delfield_command(self): del self.__field_command 
3903   
3904      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
3905   
3906 -    def __getfield_blocklen(self): 
3907          try: self.__field_blocklen 
3908          except: 
3909              self.__field_blocklen=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
3910          return self.__field_blocklen.getvalue() 
3911   
3912 -    def __setfield_blocklen(self, value): 
3913          if isinstance(value,UINT): 
3914              self.__field_blocklen=value 
3915          else: 
3916              self.__field_blocklen=UINT(value,**{'sizeinbytes': 2,  'default': 0 }) 
3917   
3918 -    def __delfield_blocklen(self): del self.__field_blocklen 
3919   
3920      blocklen=property(__getfield_blocklen, __setfield_blocklen, __delfield_blocklen, None) 
3921   
3922 -    def __getfield_entry(self): 
3923          return self.__field_entry.getvalue() 
3924   
3925 -    def __setfield_entry(self, value): 
3926          if isinstance(value,JournalEntry): 
3927              self.__field_entry=value 
3928          else: 
3929              self.__field_entry=JournalEntry(value,) 
3930   
3931 -    def __delfield_entry(self): del self.__field_entry 
3932   
3933      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
3934   
3935 -    def iscontainer(self): 
3936          return True 
3937   
3938 -    def containerelements(self): 
3939          yield ('command', self.__field_command, None) 
3940          yield ('blocklen', self.__field_blocklen, None) 
3941          yield ('entry', self.__field_entry, None) 
3942   
3943   
3944   
3945   
3946 -class JournalFile(BaseProtogenClass): 
3947      __fields=['items'] 
3948   
3949 -    def __init__(self, *args, **kwargs): 
3950          dict={} 
3951          # What was supplied to this function 
3952          dict.update(kwargs) 
3953          # Parent constructor 
3954          super(JournalFile,self).__init__(**dict) 
3955          if self.__class__ is JournalFile: 
3956              self._update(args,dict) 
3957   
3958   
3959 -    def getfields(self): 
3960          return self.__fields 
3961   
3962   
3963 -    def _update(self, args, kwargs): 
3964          super(JournalFile,self)._update(args,kwargs) 
3965          keys=kwargs.keys() 
3966          for key in keys: 
3967              if key in self.__fields: 
3968                  setattr(self, key, kwargs[key]) 
3969                  del kwargs[key] 
3970          # Were any unrecognized kwargs passed in? 
3971          if __debug__: 
3972              self._complainaboutunusedargs(JournalFile,kwargs) 
3973          if len(args): 
3974              dict2={ 'elementclass': JournalRec } 
3975              dict2.update(kwargs) 
3976              kwargs=dict2 
3977              self.__field_items=LIST(*args,**dict2) 
3978          # Make all P fields that haven't already been constructed 
3979   
3980   
3981 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3982          'Writes this packet to the supplied buffer' 
3983          self._bufferstartoffset=buf.getcurrentoffset() 
3984          try: self.__field_items 
3985          except: 
3986              self.__field_items=LIST(**{ 'elementclass': JournalRec }) 
3987          self.__field_items.writetobuffer(buf) 
3988          self._bufferendoffset=buf.getcurrentoffset() 
3989          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3990   
3991   
3992 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3993          'Reads this packet from the supplied buffer' 
3994          self._bufferstartoffset=buf.getcurrentoffset() 
3995          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3996          self.__field_items=LIST(**{ 'elementclass': JournalRec }) 
3997          self.__field_items.readfrombuffer(buf) 
3998          self._bufferendoffset=buf.getcurrentoffset() 
3999   
4000   
4001 -    def __getfield_items(self): 
4002          try: self.__field_items 
4003          except: 
4004              self.__field_items=LIST(**{ 'elementclass': JournalRec }) 
4005          return self.__field_items.getvalue() 
4006   
4007 -    def __setfield_items(self, value): 
4008          if isinstance(value,LIST): 
4009              self.__field_items=value 
4010          else: 
4011              self.__field_items=LIST(value,**{ 'elementclass': JournalRec }) 
4012   
4013 -    def __delfield_items(self): del self.__field_items 
4014   
4015      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
4016   
4017 -    def iscontainer(self): 
4018          return True 
4019   
4020 -    def containerelements(self): 
4021          yield ('items', self.__field_items, None) 
4022   
4023   
4024   
4025   
4026 -class NumberEntry(BaseProtogenClass): 
4027      # Read-From-Buffer-Only Class 
4028      __fields=['number', 'option', 'speeddial', 'ringtone'] 
4029   
4030 -    def __init__(self, *args, **kwargs): 
4031          dict={} 
4032          # What was supplied to this function 
4033          dict.update(kwargs) 
4034          # Parent constructor 
4035          super(NumberEntry,self).__init__(**dict) 
4036          if self.__class__ is NumberEntry: 
4037              self._update(args,dict) 
4038   
4039   
4040 -    def getfields(self): 
4041          return self.__fields 
4042   
4043   
4044 -    def _update(self, args, kwargs): 
4045          super(NumberEntry,self)._update(args,kwargs) 
4046          keys=kwargs.keys() 
4047          for key in keys: 
4048              if key in self.__fields: 
4049                  setattr(self, key, kwargs[key]) 
4050                  del kwargs[key] 
4051          # Were any unrecognized kwargs passed in? 
4052          if __debug__: 
4053              self._complainaboutunusedargs(NumberEntry,kwargs) 
4054          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
4055          # Make all P fields that haven't already been constructed 
4056   
4057   
4058 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
4059          'Writes this packet to the supplied buffer' 
4060          raise NotImplementedError 
4061   
4062   
4063 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
4064          'Reads this packet from the supplied buffer' 
4065          self._bufferstartoffset=buf.getcurrentoffset() 
4066          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
4067          self.__field_number=STRING(**{ 'terminator': None,               'pascal': True }) 
4068          self.__field_number.readfrombuffer(buf) 
4069          self.__field_option=UINT(**{'sizeinbytes': 1}) 
4070          self.__field_option.readfrombuffer(buf) 
4071          if self.has_speeddial: 
4072              self.__field_speeddial=UINT(**{'sizeinbytes': 2}) 
4073              self.__field_speeddial.readfrombuffer(buf) 
4074          if self.has_ringtone: 
4075              self.__field_ringtone=STRING(**{ 'terminator': None,                   'pascal': True }) 
4076              self.__field_ringtone.readfrombuffer(buf) 
4077          self._bufferendoffset=buf.getcurrentoffset() 
4078   
4079   
4080 -    def __getfield_number(self): 
4081          return self.__field_number.getvalue() 
4082   
4083 -    def __setfield_number(self, value): 
4084          if isinstance(value,STRING): 
4085              self.__field_number=value 
4086          else: 
4087              self.__field_number=STRING(value,**{ 'terminator': None,               'pascal': True }) 
4088   
4089 -    def __delfield_number(self): del self.__field_number 
4090   
4091      number=property(__getfield_number, __setfield_number, __delfield_number, None) 
4092   
4093 -    def __getfield_option(self): 
4094          return self.__field_option.getvalue() 
4095   
4096 -    def __setfield_option(self, value): 
4097          if isinstance(value,UINT): 
4098              self.__field_option=value 
4099          else: 
4100              self.__field_option=UINT(value,**{'sizeinbytes': 1}) 
4101   
4102 -    def __delfield_option(self): del self.__field_option 
4103   
4104      option=property(__getfield_option, __setfield_option, __delfield_option, None) 
4105   
4106 -    def __getfield_speeddial(self): 
4107          return self.__field_speeddial.getvalue() 
4108   
4109 -    def __setfield_speeddial(self, value): 
4110          if isinstance(value,UINT): 
4111              self.__field_speeddial=value 
4112          else: 
4113              self.__field_speeddial=UINT(value,**{'sizeinbytes': 2}) 
4114   
4115 -    def __delfield_speeddial(self): del self.__field_speeddial 
4116   
4117      speeddial=property(__getfield_speeddial, __setfield_speeddial, __delfield_speeddial, None) 
4118   
4119 -    def __getfield_ringtone(self): 
4120          return self.__field_ringtone.getvalue() 
4121   
4122 -    def __setfield_ringtone(self, value): 
4123          if isinstance(value,STRING): 
4124              self.__field_ringtone=value 
4125          else: 
4126              self.__field_ringtone=STRING(value,**{ 'terminator': None,                   'pascal': True }) 
4127   
4128 -    def __delfield_ringtone(self): del self.__field_ringtone 
4129   
4130      ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 
4131   
4132 -    def iscontainer(self): 
4133          return True 
4134   
4135 -    def containerelements(self): 
4136          yield ('number', self.__field_number, None) 
4137          yield ('option', self.__field_option, None) 
4138          if self.has_speeddial: 
4139              yield ('speeddial', self.__field_speeddial, None) 
4140          if self.has_ringtone: 
4141              yield ('ringtone', self.__field_ringtone, None) 
4142   
4143      @property 
4144 -    def has_speeddial(self): 
4145          return bool(self.option & PB_FLG_SPEEDDIAL) 
4146      @property 
4147 -    def has_ringtone(self): 
4148          return bool(self.option & PB_FLG_RINGTONE) 
4149      @property 
4150 -    def is_primary(self): 
4151          return bool(self.option & PB_FLG_PRIMARY) 
4152   
4153   
4154   
4155   
4156 -class PBEntry(BaseProtogenClass): 
4157      # Read-From-Buffer-Only Class 
4158      __fields=['info', 'name', 'email', 'email2', 'home', 'work', 'cell', 'fax', 'cell2', 'datetime', 'group', 'wallpaper', 'wallpaper_range'] 
4159   
4160 -    def __init__(self, *args, **kwargs): 
4161          dict={} 
4162          # What was supplied to this function 
4163          dict.update(kwargs) 
4164          # Parent constructor 
4165          super(PBEntry,self).__init__(**dict) 
4166          if self.__class__ is PBEntry: 
4167              self._update(args,dict) 
4168   
4169   
4170 -    def getfields(self): 
4171          return self.__fields 
4172   
4173   
4174 -    def _update(self, args, kwargs): 
4175          super(PBEntry,self)._update(args,kwargs) 
4176          keys=kwargs.keys() 
4177          for key in keys: 
4178              if key in self.__fields: 
4179                  setattr(self, key, kwargs[key]) 
4180                  del kwargs[key] 
4181          # Were any unrecognized kwargs passed in? 
4182          if __debug__: 
4183              self._complainaboutunusedargs(PBEntry,kwargs) 
4184          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
4185          # Make all P fields that haven't already been constructed 
4186   
4187   
4188 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
4189          'Writes this packet to the supplied buffer' 
4190          raise NotImplementedError 
4191   
4192   
4193 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
4194          'Reads this packet from the supplied buffer' 
4195          self._bufferstartoffset=buf.getcurrentoffset() 
4196          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
4197          self.__field_info=UINT(**{'sizeinbytes': 2}) 
4198          self.__field_info.readfrombuffer(buf) 
4199          DONTCARE(**{'sizeinbytes': 2}).readfrombuffer(buf) 
4200          if self.has_name: 
4201              self.__field_name=USTRING(**{ 'terminator': None,                    'encoding': ENCODING,                    'pascal': True }) 
4202              self.__field_name.readfrombuffer(buf) 
4203          if self.has_mail: 
4204              self.__field_email=USTRING(**{ 'terminator': None,                    'encoding': ENCODING,                    'pascal': True }) 
4205              self.__field_email.readfrombuffer(buf) 
4206          if self.has_email2: 
4207              self.__field_email2=USTRING(**{ 'terminator': None,                    'encoding': ENCODING,                   'pascal': True }) 
4208              self.__field_email2.readfrombuffer(buf) 
4209          if self.has_home: 
4210              self.__field_home=NumberEntry() 
4211              self.__field_home.readfrombuffer(buf) 
4212          if self.ihas_work: 
4213              self.__field_work=NumberEntry() 
4214              self.__field_work.readfrombuffer(buf) 
4215          if self.has_cell: 
4216              self.__field_cell=NumberEntry() 
4217              self.__field_cell.readfrombuffer(buf) 
4218          if self.has_fax: 
4219              self.__field_fax=NumberEntry() 
4220              self.__field_fax.readfrombuffer(buf) 
4221          if self.has_cell2: 
4222              self.__field_cell2=NumberEntry() 
4223              self.__field_cell2.readfrombuffer(buf) 
4224          if self.has_date: 
4225              self.__field_datetime=DateTime(**{'sizeinbytes': 4}) 
4226              self.__field_datetime.readfrombuffer(buf) 
4227          if self.has_group: 
4228              self.__field_group=UINT(**{'sizeinbytes': 1}) 
4229              self.__field_group.readfrombuffer(buf) 
4230          if self.has_wallpaper: 
4231              self.__field_wallpaper=STRING(**{ 'terminator': None,                   'pascal': True }) 
4232              self.__field_wallpaper.readfrombuffer(buf) 
4233              self.__field_wallpaper_range=UINT(**{'sizeinbytes': 4}) 
4234              self.__field_wallpaper_range.readfrombuffer(buf) 
4235          self._bufferendoffset=buf.getcurrentoffset() 
4236   
4237   
4238 -    def __getfield_info(self): 
4239          return self.__field_info.getvalue() 
4240   
4241 -    def __setfield_info(self, value): 
4242          if isinstance(value,UINT): 
4243              self.__field_info=value 
4244          else: 
4245              self.__field_info=UINT(value,**{'sizeinbytes': 2}) 
4246   
4247 -    def __delfield_info(self): del self.__field_info 
4248   
4249      info=property(__getfield_info, __setfield_info, __delfield_info, None) 
4250   
4251 -    def __getfield_name(self): 
4252          return self.__field_name.getvalue() 
4253   
4254 -    def __setfield_name(self, value): 
4255          if isinstance(value,USTRING): 
4256              self.__field_name=value 
4257          else: 
4258              self.__field_name=USTRING(value,**{ 'terminator': None,                    'encoding': ENCODING,                    'pascal': True }) 
4259   
4260 -    def __delfield_name(self): del self.__field_name 
4261   
4262      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
4263   
4264 -    def __getfield_email(self): 
4265          return self.__field_email.getvalue() 
4266   
4267 -    def __setfield_email(self, value): 
4268          if isinstance(value,USTRING): 
4269              self.__field_email=value 
4270          else: 
4271              self.__field_email=USTRING(value,**{ 'terminator': None,                    'encoding': ENCODING,                    'pascal': True }) 
4272   
4273 -    def __delfield_email(self): del self.__field_email 
4274   
4275      email=property(__getfield_email, __setfield_email, __delfield_email, None) 
4276   
4277 -    def __getfield_email2(self): 
4278          return self.__field_email2.getvalue() 
4279   
4280 -    def __setfield_email2(self, value): 
4281          if isinstance(value,USTRING): 
4282              self.__field_email2=value 
4283          else: 
4284              self.__field_email2=USTRING(value,**{ 'terminator': None,                    'encoding': ENCODING,                   'pascal': True }) 
4285   
4286 -    def __delfield_email2(self): del self.__field_email2 
4287   
4288      email2=property(__getfield_email2, __setfield_email2, __delfield_email2, None) 
4289   
4290 -    def __getfield_home(self): 
4291          return self.__field_home.getvalue() 
4292   
4293 -    def __setfield_home(self, value): 
4294          if isinstance(value,NumberEntry): 
4295              self.__field_home=value 
4296          else: 
4297              self.__field_home=NumberEntry(value,) 
4298   
4299 -    def __delfield_home(self): del self.__field_home 
4300   
4301      home=property(__getfield_home, __setfield_home, __delfield_home, None) 
4302   
4303 -    def __getfield_work(self): 
4304          return self.__field_work.getvalue() 
4305   
4306 -    def __setfield_work(self, value): 
4307          if isinstance(value,NumberEntry): 
4308              self.__field_work=value 
4309          else: 
4310              self.__field_work=NumberEntry(value,) 
4311   
4312 -    def __delfield_work(self): del self.__field_work 
4313   
4314      work=property(__getfield_work, __setfield_work, __delfield_work, None) 
4315   
4316 -    def __getfield_cell(self): 
4317          return self.__field_cell.getvalue() 
4318   
4319 -    def __setfield_cell(self, value): 
4320          if isinstance(value,NumberEntry): 
4321              self.__field_cell=value 
4322          else: 
4323              self.__field_cell=NumberEntry(value,) 
4324   
4325 -    def __delfield_cell(self): del self.__field_cell 
4326   
4327      cell=property(__getfield_cell, __setfield_cell, __delfield_cell, None) 
4328   
4329 -    def __getfield_fax(self): 
4330          return self.__field_fax.getvalue() 
4331   
4332 -    def __setfield_fax(self, value): 
4333          if isinstance(value,NumberEntry): 
4334              self.__field_fax=value 
4335          else: 
4336              self.__field_fax=NumberEntry(value,) 
4337   
4338 -    def __delfield_fax(self): del self.__field_fax 
4339   
4340      fax=property(__getfield_fax, __setfield_fax, __delfield_fax, None) 
4341   
4342 -    def __getfield_cell2(self): 
4343          return self.__field_cell2.getvalue() 
4344   
4345 -    def __setfield_cell2(self, value): 
4346          if isinstance(value,NumberEntry): 
4347              self.__field_cell2=value 
4348          else: 
4349              self.__field_cell2=NumberEntry(value,) 
4350   
4351 -    def __delfield_cell2(self): del self.__field_cell2 
4352   
4353      cell2=property(__getfield_cell2, __setfield_cell2, __delfield_cell2, None) 
4354   
4355 -    def __getfield_datetime(self): 
4356          return self.__field_datetime.getvalue() 
4357   
4358 -    def __setfield_datetime(self, value): 
4359          if isinstance(value,DateTime): 
4360              self.__field_datetime=value 
4361          else: 
4362              self.__field_datetime=DateTime(value,**{'sizeinbytes': 4}) 
4363   
4364 -    def __delfield_datetime(self): del self.__field_datetime 
4365   
4366      datetime=property(__getfield_datetime, __setfield_datetime, __delfield_datetime, None) 
4367   
4368 -    def __getfield_group(self): 
4369          return self.__field_group.getvalue() 
4370   
4371 -    def __setfield_group(self, value): 
4372          if isinstance(value,UINT): 
4373              self.__field_group=value 
4374          else: 
4375              self.__field_group=UINT(value,**{'sizeinbytes': 1}) 
4376   
4377 -    def __delfield_group(self): del self.__field_group 
4378   
4379      group=property(__getfield_group, __setfield_group, __delfield_group, None) 
4380   
4381 -    def __getfield_wallpaper(self): 
4382          return self.__field_wallpaper.getvalue() 
4383   
4384 -    def __setfield_wallpaper(self, value): 
4385          if isinstance(value,STRING): 
4386              self.__field_wallpaper=value 
4387          else: 
4388              self.__field_wallpaper=STRING(value,**{ 'terminator': None,                   'pascal': True }) 
4389   
4390 -    def __delfield_wallpaper(self): del self.__field_wallpaper 
4391   
4392      wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None) 
4393   
4394 -    def __getfield_wallpaper_range(self): 
4395          return self.__field_wallpaper_range.getvalue() 
4396   
4397 -    def __setfield_wallpaper_range(self, value): 
4398          if isinstance(value,UINT): 
4399              self.__field_wallpaper_range=value 
4400          else: 
4401              self.__field_wallpaper_range=UINT(value,**{'sizeinbytes': 4}) 
4402   
4403 -    def __delfield_wallpaper_range(self): del self.__field_wallpaper_range 
4404   
4405      wallpaper_range=property(__getfield_wallpaper_range, __setfield_wallpaper_range, __delfield_wallpaper_range, None) 
4406   
4407 -    def iscontainer(self): 
4408          return True 
4409   
4410 -    def containerelements(self): 
4411          yield ('info', self.__field_info, None) 
4412          if self.has_name: 
4413              yield ('name', self.__field_name, None) 
4414          if self.has_mail: 
4415              yield ('email', self.__field_email, None) 
4416          if self.has_email2: 
4417              yield ('email2', self.__field_email2, None) 
4418          if self.has_home: 
4419              yield ('home', self.__field_home, None) 
4420          if self.ihas_work: 
4421              yield ('work', self.__field_work, None) 
4422          if self.has_cell: 
4423              yield ('cell', self.__field_cell, None) 
4424          if self.has_fax: 
4425              yield ('fax', self.__field_fax, None) 
4426          if self.has_cell2: 
4427              yield ('cell2', self.__field_cell2, None) 
4428          if self.has_date: 
4429              yield ('datetime', self.__field_datetime, None) 
4430          if self.has_group: 
4431              yield ('group', self.__field_group, None) 
4432          if self.has_wallpaper: 
4433              yield ('wallpaper', self.__field_wallpaper, None) 
4434              yield ('wallpaper_range', self.__field_wallpaper_range, None) 
4435   
4436      @property 
4437 -    def has_name(self): 
4438          return bool(self.info & PB_FLG_NAME) 
4439      @property 
4440 -    def has_email(self): 
4441          return bool(self.info & PB_FLG_EMAIL) 
4442      @property 
4443 -    def has_email2(self): 
4444          return bool(self.info & PB_FLG_EMAIL2) 
4445      @property 
4446 -    def has_home(self): 
4447          return bool(self.info & PB_FLG_HOME) 
4448      @property 
4449 -    def has_work(self): 
4450          return bool(self.info & PB_FLG_WORK) 
4451      @property 
4452 -    def has_cell(self): 
4453          return bool(self.info & PB_FLG_CELL) 
4454      @property 
4455 -    def has_fax(self): 
4456          return bool(self.info & PB_FLG_FAX) 
4457      @property 
4458 -    def has_cell2(self): 
4459          return bool(self.info & PB_FLG_CELL2) 
4460      @property 
4461 -    def has_date(self): 
4462          return bool(self.info & PB_FLG_DATE) 
4463      @property 
4464 -    def has_group(self): 
4465          return bool(self.info & PB_FLG_GROUP) 
4466      @property 
4467 -    def has_wallpaper(self): 
4468          return bool(self.info & PB_FLG_WP) 
4469   
4470   
4471   
4472   
4473 -class LenEntry(BaseProtogenClass): 
4474      # Read-From-Buffer-Only Class 
4475      __fields=['itemlen'] 
4476   
4477 -    def __init__(self, *args, **kwargs): 
4478          dict={} 
4479          # What was supplied to this function 
4480          dict.update(kwargs) 
4481          # Parent constructor 
4482          super(LenEntry,self).__init__(**dict) 
4483          if self.__class__ is LenEntry: 
4484              self._update(args,dict) 
4485   
4486   
4487 -    def getfields(self): 
4488          return self.__fields 
4489   
4490   
4491 -    def _update(self, args, kwargs): 
4492          super(LenEntry,self)._update(args,kwargs) 
4493          keys=kwargs.keys() 
4494          for key in keys: 
4495              if key in self.__fields: 
4496                  setattr(self, key, kwargs[key]) 
4497                  del kwargs[key] 
4498          # Were any unrecognized kwargs passed in? 
4499          if __debug__: 
4500              self._complainaboutunusedargs(LenEntry,kwargs) 
4501          if len(args): 
4502              dict2={'sizeinbytes': 2,  'default': 0 } 
4503              dict2.update(kwargs) 
4504              kwargs=dict2 
4505              self.__field_itemlen=UINT(*args,**dict2) 
4506          # Make all P fields that haven't already been constructed 
4507   
4508   
4509 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
4510          'Writes this packet to the supplied buffer' 
4511          raise NotImplementedError 
4512   
4513   
4514 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
4515          'Reads this packet from the supplied buffer' 
4516          self._bufferstartoffset=buf.getcurrentoffset() 
4517          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
4518          self.__field_itemlen=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
4519          self.__field_itemlen.readfrombuffer(buf) 
4520          self._bufferendoffset=buf.getcurrentoffset() 
4521   
4522   
4523 -    def __getfield_itemlen(self): 
4524          try: self.__field_itemlen 
4525          except: 
4526              self.__field_itemlen=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
4527          return self.__field_itemlen.getvalue() 
4528   
4529 -    def __setfield_itemlen(self, value): 
4530          if isinstance(value,UINT): 
4531              self.__field_itemlen=value 
4532          else: 
4533              self.__field_itemlen=UINT(value,**{'sizeinbytes': 2,  'default': 0 }) 
4534   
4535 -    def __delfield_itemlen(self): del self.__field_itemlen 
4536   
4537      itemlen=property(__getfield_itemlen, __setfield_itemlen, __delfield_itemlen, None) 
4538   
4539 -    def iscontainer(self): 
4540          return True 
4541   
4542 -    def containerelements(self): 
4543          yield ('itemlen', self.__field_itemlen, None) 
4544   
4545   
4546   
4547   
4548 -class PBFile(BaseProtogenClass): 
4549      # Read-From-Buffer-Only Class 
4550      __fields=['lens', 'items'] 
4551   
4552 -    def __init__(self, *args, **kwargs): 
4553          dict={} 
4554          # What was supplied to this function 
4555          dict.update(kwargs) 
4556          # Parent constructor 
4557          super(PBFile,self).__init__(**dict) 
4558          if self.__class__ is PBFile: 
4559              self._update(args,dict) 
4560   
4561   
4562 -    def getfields(self): 
4563          return self.__fields 
4564   
4565   
4566 -    def _update(self, args, kwargs): 
4567          super(PBFile,self)._update(args,kwargs) 
4568          keys=kwargs.keys() 
4569          for key in keys: 
4570              if key in self.__fields: 
4571                  setattr(self, key, kwargs[key]) 
4572                  del kwargs[key] 
4573          # Were any unrecognized kwargs passed in? 
4574          if __debug__: 
4575              self._complainaboutunusedargs(PBFile,kwargs) 
4576          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
4577          # Make all P fields that haven't already been constructed 
4578   
4579   
4580 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
4581          'Writes this packet to the supplied buffer' 
4582          raise NotImplementedError 
4583   
4584   
4585 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
4586          'Reads this packet from the supplied buffer' 
4587          self._bufferstartoffset=buf.getcurrentoffset() 
4588          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
4589          self.__field_lens=LIST(**{ 'elementclass': LenEntry,             'length': 8,             'createdefault': True }) 
4590          self.__field_lens.readfrombuffer(buf) 
4591          self.__field_items=LIST(**{ 'elementclass': PBEntry }) 
4592          self.__field_items.readfrombuffer(buf) 
4593          self._bufferendoffset=buf.getcurrentoffset() 
4594   
4595   
4596 -    def __getfield_lens(self): 
4597          try: self.__field_lens 
4598          except: 
4599              self.__field_lens=LIST(**{ 'elementclass': LenEntry,             'length': 8,             'createdefault': True }) 
4600          return self.__field_lens.getvalue() 
4601   
4602 -    def __setfield_lens(self, value): 
4603          if isinstance(value,LIST): 
4604              self.__field_lens=value 
4605          else: 
4606              self.__field_lens=LIST(value,**{ 'elementclass': LenEntry,             'length': 8,             'createdefault': True }) 
4607   
4608 -    def __delfield_lens(self): del self.__field_lens 
4609   
4610      lens=property(__getfield_lens, __setfield_lens, __delfield_lens, None) 
4611   
4612 -    def __getfield_items(self): 
4613          try: self.__field_items 
4614          except: 
4615              self.__field_items=LIST(**{ 'elementclass': PBEntry }) 
4616          return self.__field_items.getvalue() 
4617   
4618 -    def __setfield_items(self, value): 
4619          if isinstance(value,LIST): 
4620              self.__field_items=value 
4621          else: 
4622              self.__field_items=LIST(value,**{ 'elementclass': PBEntry }) 
4623   
4624 -    def __delfield_items(self): del self.__field_items 
4625   
4626      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
4627   
4628 -    def iscontainer(self): 
4629          return True 
4630   
4631 -    def containerelements(self): 
4632          yield ('lens', self.__field_lens, None) 
4633          yield ('items', self.__field_items, None) 
4634   
4635   
4636   
4637   
4638 -class PBFileHeader(BaseProtogenClass): 
4639      # Read-From-Buffer-Only Class 
4640      __fields=['lens'] 
4641   
4642 -    def __init__(self, *args, **kwargs): 
4643          dict={} 
4644          # What was supplied to this function 
4645          dict.update(kwargs) 
4646          # Parent constructor 
4647          super(PBFileHeader,self).__init__(**dict) 
4648          if self.__class__ is PBFileHeader: 
4649              self._update(args,dict) 
4650   
4651   
4652 -    def getfields(self): 
4653          return self.__fields 
4654   
4655   
4656 -    def _update(self, args, kwargs): 
4657          super(PBFileHeader,self)._update(args,kwargs) 
4658          keys=kwargs.keys() 
4659          for key in keys: 
4660              if key in self.__fields: 
4661                  setattr(self, key, kwargs[key]) 
4662                  del kwargs[key] 
4663          # Were any unrecognized kwargs passed in? 
4664          if __debug__: 
4665              self._complainaboutunusedargs(PBFileHeader,kwargs) 
4666          if len(args): 
4667              dict2={ 'elementclass': LenEntry,             'length': 8,             'createdefault': True } 
4668              dict2.update(kwargs) 
4669              kwargs=dict2 
4670              self.__field_lens=LIST(*args,**dict2) 
4671          # Make all P fields that haven't already been constructed 
4672   
4673   
4674 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
4675          'Writes this packet to the supplied buffer' 
4676          raise NotImplementedError 
4677   
4678   
4679 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
4680          'Reads this packet from the supplied buffer' 
4681          self._bufferstartoffset=buf.getcurrentoffset() 
4682          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
4683          self.__field_lens=LIST(**{ 'elementclass': LenEntry,             'length': 8,             'createdefault': True }) 
4684          self.__field_lens.readfrombuffer(buf) 
4685          self._bufferendoffset=buf.getcurrentoffset() 
4686   
4687   
4688 -    def __getfield_lens(self): 
4689          try: self.__field_lens 
4690          except: 
4691              self.__field_lens=LIST(**{ 'elementclass': LenEntry,             'length': 8,             'createdefault': True }) 
4692          return self.__field_lens.getvalue() 
4693   
4694 -    def __setfield_lens(self, value): 
4695          if isinstance(value,LIST): 
4696              self.__field_lens=value 
4697          else: 
4698              self.__field_lens=LIST(value,**{ 'elementclass': LenEntry,             'length': 8,             'createdefault': True }) 
4699   
4700 -    def __delfield_lens(self): del self.__field_lens 
4701   
4702      lens=property(__getfield_lens, __setfield_lens, __delfield_lens, None) 
4703   
4704 -    def iscontainer(self): 
4705          return True 
4706   
4707 -    def containerelements(self): 
4708          yield ('lens', self.__field_lens, None) 
4709   
4710   
4711   
4712   
4713 -class ss_cmd_hdr(BaseProtogenClass): 
4714      __fields=['commandcode', 'command'] 
4715   
4716 -    def __init__(self, *args, **kwargs): 
4717          dict={} 
4718          # What was supplied to this function 
4719          dict.update(kwargs) 
4720          # Parent constructor 
4721          super(ss_cmd_hdr,self).__init__(**dict) 
4722          if self.__class__ is ss_cmd_hdr: 
4723              self._update(args,dict) 
4724   
4725   
4726 -    def getfields(self): 
4727          return self.__fields 
4728   
4729   
4730 -    def _update(self, args, kwargs): 
4731          super(ss_cmd_hdr,self)._update(args,kwargs) 
4732          keys=kwargs.keys() 
4733          for key in keys: 
4734              if key in self.__fields: 
4735                  setattr(self, key, kwargs[key]) 
4736                  del kwargs[key] 
4737          # Were any unrecognized kwargs passed in? 
4738          if __debug__: 
4739              self._complainaboutunusedargs(ss_cmd_hdr,kwargs) 
4740          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
4741          # Make all P fields that haven't already been constructed 
4742   
4743   
4744 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
4745          'Writes this packet to the supplied buffer' 
4746          self._bufferstartoffset=buf.getcurrentoffset() 
4747          try: self.__field_commandcode 
4748          except: 
4749              self.__field_commandcode=UINT(**{'sizeinbytes': 4,  'default': 0xfa4b }) 
4750          self.__field_commandcode.writetobuffer(buf) 
4751          self.__field_command.writetobuffer(buf) 
4752          self._bufferendoffset=buf.getcurrentoffset() 
4753          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
4754   
4755   
4756 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
4757          'Reads this packet from the supplied buffer' 
4758          self._bufferstartoffset=buf.getcurrentoffset() 
4759          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
4760          self.__field_commandcode=UINT(**{'sizeinbytes': 4,  'default': 0xfa4b }) 
4761          self.__field_commandcode.readfrombuffer(buf) 
4762          self.__field_command=UINT(**{'sizeinbytes': 1}) 
4763          self.__field_command.readfrombuffer(buf) 
4764          self._bufferendoffset=buf.getcurrentoffset() 
4765   
4766   
4767 -    def __getfield_commandcode(self): 
4768          try: self.__field_commandcode 
4769          except: 
4770              self.__field_commandcode=UINT(**{'sizeinbytes': 4,  'default': 0xfa4b }) 
4771          return self.__field_commandcode.getvalue() 
4772   
4773 -    def __setfield_commandcode(self, value): 
4774          if isinstance(value,UINT): 
4775              self.__field_commandcode=value 
4776          else: 
4777              self.__field_commandcode=UINT(value,**{'sizeinbytes': 4,  'default': 0xfa4b }) 
4778   
4779 -    def __delfield_commandcode(self): del self.__field_commandcode 
4780   
4781      commandcode=property(__getfield_commandcode, __setfield_commandcode, __delfield_commandcode, None) 
4782   
4783 -    def __getfield_command(self): 
4784          return self.__field_command.getvalue() 
4785   
4786 -    def __setfield_command(self, value): 
4787          if isinstance(value,UINT): 
4788              self.__field_command=value 
4789          else: 
4790              self.__field_command=UINT(value,**{'sizeinbytes': 1}) 
4791   
4792 -    def __delfield_command(self): del self.__field_command 
4793   
4794      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
4795   
4796 -    def iscontainer(self): 
4797          return True 
4798   
4799 -    def containerelements(self): 
4800          yield ('commandcode', self.__field_commandcode, None) 
4801          yield ('command', self.__field_command, None) 
4802   
4803   
4804   
4805   
4806 -class ss_cmd_resp(BaseProtogenClass): 
4807      # Read-From-Buffer-Only Class 
4808      __fields=['cmd_hdr', 'data'] 
4809   
4810 -    def __init__(self, *args, **kwargs): 
4811          dict={} 
4812          # What was supplied to this function 
4813          dict.update(kwargs) 
4814          # Parent constructor 
4815          super(ss_cmd_resp,self).__init__(**dict) 
4816          if self.__class__ is ss_cmd_resp: 
4817              self._update(args,dict) 
4818   
4819   
4820 -    def getfields(self): 
4821          return self.__fields 
4822   
4823   
4824 -    def _update(self, args, kwargs): 
4825          super(ss_cmd_resp,self)._update(args,kwargs) 
4826          keys=kwargs.keys() 
4827          for key in keys: 
4828              if key in self.__fields: 
4829                  setattr(self, key, kwargs[key]) 
4830                  del kwargs[key] 
4831          # Were any unrecognized kwargs passed in? 
4832          if __debug__: 
4833              self._complainaboutunusedargs(ss_cmd_resp,kwargs) 
4834          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
4835          # Make all P fields that haven't already been constructed 
4836   
4837   
4838 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
4839          'Writes this packet to the supplied buffer' 
4840          raise NotImplementedError 
4841   
4842   
4843 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
4844          'Reads this packet from the supplied buffer' 
4845          self._bufferstartoffset=buf.getcurrentoffset() 
4846          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
4847          self.__field_cmd_hdr=ss_cmd_hdr() 
4848          self.__field_cmd_hdr.readfrombuffer(buf) 
4849          self.__field_data=DATA() 
4850          self.__field_data.readfrombuffer(buf) 
4851          self._bufferendoffset=buf.getcurrentoffset() 
4852   
4853   
4854 -    def __getfield_cmd_hdr(self): 
4855          return self.__field_cmd_hdr.getvalue() 
4856   
4857 -    def __setfield_cmd_hdr(self, value): 
4858          if isinstance(value,ss_cmd_hdr): 
4859              self.__field_cmd_hdr=value 
4860          else: 
4861              self.__field_cmd_hdr=ss_cmd_hdr(value,) 
4862   
4863 -    def __delfield_cmd_hdr(self): del self.__field_cmd_hdr 
4864   
4865      cmd_hdr=property(__getfield_cmd_hdr, __setfield_cmd_hdr, __delfield_cmd_hdr, None) 
4866   
4867 -    def __getfield_data(self): 
4868          return self.__field_data.getvalue() 
4869   
4870 -    def __setfield_data(self, value): 
4871          if isinstance(value,DATA): 
4872              self.__field_data=value 
4873          else: 
4874              self.__field_data=DATA(value,) 
4875   
4876 -    def __delfield_data(self): del self.__field_data 
4877   
4878      data=property(__getfield_data, __setfield_data, __delfield_data, None) 
4879   
4880 -    def iscontainer(self): 
4881          return True 
4882   
4883 -    def containerelements(self): 
4884          yield ('cmd_hdr', self.__field_cmd_hdr, None) 
4885          yield ('data', self.__field_data, None) 
4886   
4887   
4888   
4889   
4890 -class ss_sw_req(BaseProtogenClass): 
4891      __fields=['hdr'] 
4892   
4893 -    def __init__(self, *args, **kwargs): 
4894          dict={} 
4895          # What was supplied to this function 
4896          dict.update(kwargs) 
4897          # Parent constructor 
4898          super(ss_sw_req,self).__init__(**dict) 
4899          if self.__class__ is ss_sw_req: 
4900              self._update(args,dict) 
4901   
4902   
4903 -    def getfields(self): 
4904          return self.__fields 
4905   
4906   
4907 -    def _update(self, args, kwargs): 
4908          super(ss_sw_req,self)._update(args,kwargs) 
4909          keys=kwargs.keys() 
4910          for key in keys: 
4911              if key in self.__fields: 
4912                  setattr(self, key, kwargs[key]) 
4913                  del kwargs[key] 
4914          # Were any unrecognized kwargs passed in? 
4915          if __debug__: 
4916              self._complainaboutunusedargs(ss_sw_req,kwargs) 
4917          if len(args): 
4918              dict2={ 'command': SS_CMD_SW_VERSION } 
4919              dict2.update(kwargs) 
4920              kwargs=dict2 
4921              self.__field_hdr=ss_cmd_hdr(*args,**dict2) 
4922          # Make all P fields that haven't already been constructed 
4923   
4924   
4925 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
4926          'Writes this packet to the supplied buffer' 
4927          self._bufferstartoffset=buf.getcurrentoffset() 
4928          try: self.__field_hdr 
4929          except: 
4930              self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_SW_VERSION }) 
4931          self.__field_hdr.writetobuffer(buf) 
4932          self._bufferendoffset=buf.getcurrentoffset() 
4933          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
4934   
4935   
4936 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
4937          'Reads this packet from the supplied buffer' 
4938          self._bufferstartoffset=buf.getcurrentoffset() 
4939          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
4940          self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_SW_VERSION }) 
4941          self.__field_hdr.readfrombuffer(buf) 
4942          self._bufferendoffset=buf.getcurrentoffset() 
4943   
4944   
4945 -    def __getfield_hdr(self): 
4946          try: self.__field_hdr 
4947          except: 
4948              self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_SW_VERSION }) 
4949          return self.__field_hdr.getvalue() 
4950   
4951 -    def __setfield_hdr(self, value): 
4952          if isinstance(value,ss_cmd_hdr): 
4953              self.__field_hdr=value 
4954          else: 
4955              self.__field_hdr=ss_cmd_hdr(value,**{ 'command': SS_CMD_SW_VERSION }) 
4956   
4957 -    def __delfield_hdr(self): del self.__field_hdr 
4958   
4959      hdr=property(__getfield_hdr, __setfield_hdr, __delfield_hdr, None) 
4960   
4961 -    def iscontainer(self): 
4962          return True 
4963   
4964 -    def containerelements(self): 
4965          yield ('hdr', self.__field_hdr, None) 
4966   
4967   
4968   
4969   
4970 -class ss_sw_resp(BaseProtogenClass): 
4971      # Read-From-Buffer-Only Class 
4972      __fields=['hdr', 'sw_version'] 
4973   
4974 -    def __init__(self, *args, **kwargs): 
4975          dict={} 
4976          # What was supplied to this function 
4977          dict.update(kwargs) 
4978          # Parent constructor 
4979          super(ss_sw_resp,self).__init__(**dict) 
4980          if self.__class__ is ss_sw_resp: 
4981              self._update(args,dict) 
4982   
4983   
4984 -    def getfields(self): 
4985          return self.__fields 
4986   
4987   
4988 -    def _update(self, args, kwargs): 
4989          super(ss_sw_resp,self)._update(args,kwargs) 
4990          keys=kwargs.keys() 
4991          for key in keys: 
4992              if key in self.__fields: 
4993                  setattr(self, key, kwargs[key]) 
4994                  del kwargs[key] 
4995          # Were any unrecognized kwargs passed in? 
4996          if __debug__: 
4997              self._complainaboutunusedargs(ss_sw_resp,kwargs) 
4998          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
4999          # Make all P fields that haven't already been constructed 
5000   
5001   
5002 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
5003          'Writes this packet to the supplied buffer' 
5004          raise NotImplementedError 
5005   
5006   
5007 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
5008          'Reads this packet from the supplied buffer' 
5009          self._bufferstartoffset=buf.getcurrentoffset() 
5010          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
5011          self.__field_hdr=ss_cmd_hdr() 
5012          self.__field_hdr.readfrombuffer(buf) 
5013          self.__field_sw_version=STRING(**{ 'terminator': 0 }) 
5014          self.__field_sw_version.readfrombuffer(buf) 
5015          self._bufferendoffset=buf.getcurrentoffset() 
5016   
5017   
5018 -    def __getfield_hdr(self): 
5019          return self.__field_hdr.getvalue() 
5020   
5021 -    def __setfield_hdr(self, value): 
5022          if isinstance(value,ss_cmd_hdr): 
5023              self.__field_hdr=value 
5024          else: 
5025              self.__field_hdr=ss_cmd_hdr(value,) 
5026   
5027 -    def __delfield_hdr(self): del self.__field_hdr 
5028   
5029      hdr=property(__getfield_hdr, __setfield_hdr, __delfield_hdr, None) 
5030   
5031 -    def __getfield_sw_version(self): 
5032          return self.__field_sw_version.getvalue() 
5033   
5034 -    def __setfield_sw_version(self, value): 
5035          if isinstance(value,STRING): 
5036              self.__field_sw_version=value 
5037          else: 
5038              self.__field_sw_version=STRING(value,**{ 'terminator': 0 }) 
5039   
5040 -    def __delfield_sw_version(self): del self.__field_sw_version 
5041   
5042      sw_version=property(__getfield_sw_version, __setfield_sw_version, __delfield_sw_version, None) 
5043   
5044 -    def iscontainer(self): 
5045          return True 
5046   
5047 -    def containerelements(self): 
5048          yield ('hdr', self.__field_hdr, None) 
5049          yield ('sw_version', self.__field_sw_version, None) 
5050   
5051   
5052   
5053   
5054 -class ss_hw_req(BaseProtogenClass): 
5055      __fields=['hdr'] 
5056   
5057 -    def __init__(self, *args, **kwargs): 
5058          dict={} 
5059          # What was supplied to this function 
5060          dict.update(kwargs) 
5061          # Parent constructor 
5062          super(ss_hw_req,self).__init__(**dict) 
5063          if self.__class__ is ss_hw_req: 
5064              self._update(args,dict) 
5065   
5066   
5067 -    def getfields(self): 
5068          return self.__fields 
5069   
5070   
5071 -    def _update(self, args, kwargs): 
5072          super(ss_hw_req,self)._update(args,kwargs) 
5073          keys=kwargs.keys() 
5074          for key in keys: 
5075              if key in self.__fields: 
5076                  setattr(self, key, kwargs[key]) 
5077                  del kwargs[key] 
5078          # Were any unrecognized kwargs passed in? 
5079          if __debug__: 
5080              self._complainaboutunusedargs(ss_hw_req,kwargs) 
5081          if len(args): 
5082              dict2={ 'command': SS_CMD_HW_VERSION } 
5083              dict2.update(kwargs) 
5084              kwargs=dict2 
5085              self.__field_hdr=ss_cmd_hdr(*args,**dict2) 
5086          # Make all P fields that haven't already been constructed 
5087   
5088   
5089 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
5090          'Writes this packet to the supplied buffer' 
5091          self._bufferstartoffset=buf.getcurrentoffset() 
5092          try: self.__field_hdr 
5093          except: 
5094              self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_HW_VERSION }) 
5095          self.__field_hdr.writetobuffer(buf) 
5096          self._bufferendoffset=buf.getcurrentoffset() 
5097          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
5098   
5099   
5100 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
5101          'Reads this packet from the supplied buffer' 
5102          self._bufferstartoffset=buf.getcurrentoffset() 
5103          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
5104          self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_HW_VERSION }) 
5105          self.__field_hdr.readfrombuffer(buf) 
5106          self._bufferendoffset=buf.getcurrentoffset() 
5107   
5108   
5109 -    def __getfield_hdr(self): 
5110          try: self.__field_hdr 
5111          except: 
5112              self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_HW_VERSION }) 
5113          return self.__field_hdr.getvalue() 
5114   
5115 -    def __setfield_hdr(self, value): 
5116          if isinstance(value,ss_cmd_hdr): 
5117              self.__field_hdr=value 
5118          else: 
5119              self.__field_hdr=ss_cmd_hdr(value,**{ 'command': SS_CMD_HW_VERSION }) 
5120   
5121 -    def __delfield_hdr(self): del self.__field_hdr 
5122   
5123      hdr=property(__getfield_hdr, __setfield_hdr, __delfield_hdr, None) 
5124   
5125 -    def iscontainer(self): 
5126          return True 
5127   
5128 -    def containerelements(self): 
5129          yield ('hdr', self.__field_hdr, None) 
5130   
5131   
5132   
5133   
5134 -class ss_hw_resp(BaseProtogenClass): 
5135      # Read-From-Buffer-Only Class 
5136      __fields=['hdr', 'hw_version'] 
5137   
5138 -    def __init__(self, *args, **kwargs): 
5139          dict={} 
5140          # What was supplied to this function 
5141          dict.update(kwargs) 
5142          # Parent constructor 
5143          super(ss_hw_resp,self).__init__(**dict) 
5144          if self.__class__ is ss_hw_resp: 
5145              self._update(args,dict) 
5146   
5147   
5148 -    def getfields(self): 
5149          return self.__fields 
5150   
5151   
5152 -    def _update(self, args, kwargs): 
5153          super(ss_hw_resp,self)._update(args,kwargs) 
5154          keys=kwargs.keys() 
5155          for key in keys: 
5156              if key in self.__fields: 
5157                  setattr(self, key, kwargs[key]) 
5158                  del kwargs[key] 
5159          # Were any unrecognized kwargs passed in? 
5160          if __debug__: 
5161              self._complainaboutunusedargs(ss_hw_resp,kwargs) 
5162          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
5163          # Make all P fields that haven't already been constructed 
5164   
5165   
5166 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
5167          'Writes this packet to the supplied buffer' 
5168          raise NotImplementedError 
5169   
5170   
5171 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
5172          'Reads this packet from the supplied buffer' 
5173          self._bufferstartoffset=buf.getcurrentoffset() 
5174          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
5175          self.__field_hdr=ss_cmd_hdr() 
5176          self.__field_hdr.readfrombuffer(buf) 
5177          self.__field_hw_version=STRING(**{ 'terminator': 0 }) 
5178          self.__field_hw_version.readfrombuffer(buf) 
5179          self._bufferendoffset=buf.getcurrentoffset() 
5180   
5181   
5182 -    def __getfield_hdr(self): 
5183          return self.__field_hdr.getvalue() 
5184   
5185 -    def __setfield_hdr(self, value): 
5186          if isinstance(value,ss_cmd_hdr): 
5187              self.__field_hdr=value 
5188          else: 
5189              self.__field_hdr=ss_cmd_hdr(value,) 
5190   
5191 -    def __delfield_hdr(self): del self.__field_hdr 
5192   
5193      hdr=property(__getfield_hdr, __setfield_hdr, __delfield_hdr, None) 
5194   
5195 -    def __getfield_hw_version(self): 
5196          return self.__field_hw_version.getvalue() 
5197   
5198 -    def __setfield_hw_version(self, value): 
5199          if isinstance(value,STRING): 
5200              self.__field_hw_version=value 
5201          else: 
5202              self.__field_hw_version=STRING(value,**{ 'terminator': 0 }) 
5203   
5204 -    def __delfield_hw_version(self): del self.__field_hw_version 
5205   
5206      hw_version=property(__getfield_hw_version, __setfield_hw_version, __delfield_hw_version, None) 
5207   
5208 -    def iscontainer(self): 
5209          return True 
5210   
5211 -    def containerelements(self): 
5212          yield ('hdr', self.__field_hdr, None) 
5213          yield ('hw_version', self.__field_hw_version, None) 
5214   
5215   
5216   
5217   
5218 -class ss_pb_count_req(BaseProtogenClass): 
5219      __fields=['hdr'] 
5220   
5221 -    def __init__(self, *args, **kwargs): 
5222          dict={} 
5223          # What was supplied to this function 
5224          dict.update(kwargs) 
5225          # Parent constructor 
5226          super(ss_pb_count_req,self).__init__(**dict) 
5227          if self.__class__ is ss_pb_count_req: 
5228              self._update(args,dict) 
5229   
5230   
5231 -    def getfields(self): 
5232          return self.__fields 
5233   
5234   
5235 -    def _update(self, args, kwargs): 
5236          super(ss_pb_count_req,self)._update(args,kwargs) 
5237          keys=kwargs.keys() 
5238          for key in keys: 
5239              if key in self.__fields: 
5240                  setattr(self, key, kwargs[key]) 
5241                  del kwargs[key] 
5242          # Were any unrecognized kwargs passed in? 
5243          if __debug__: 
5244              self._complainaboutunusedargs(ss_pb_count_req,kwargs) 
5245          if len(args): 
5246              dict2={ 'command': SS_CMD_PB_COUNT } 
5247              dict2.update(kwargs) 
5248              kwargs=dict2 
5249              self.__field_hdr=ss_cmd_hdr(*args,**dict2) 
5250          # Make all P fields that haven't already been constructed 
5251   
5252   
5253 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
5254          'Writes this packet to the supplied buffer' 
5255          self._bufferstartoffset=buf.getcurrentoffset() 
5256          try: self.__field_hdr 
5257          except: 
5258              self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_COUNT }) 
5259          self.__field_hdr.writetobuffer(buf) 
5260          self._bufferendoffset=buf.getcurrentoffset() 
5261          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
5262   
5263   
5264 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
5265          'Reads this packet from the supplied buffer' 
5266          self._bufferstartoffset=buf.getcurrentoffset() 
5267          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
5268          self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_COUNT }) 
5269          self.__field_hdr.readfrombuffer(buf) 
5270          self._bufferendoffset=buf.getcurrentoffset() 
5271   
5272   
5273 -    def __getfield_hdr(self): 
5274          try: self.__field_hdr 
5275          except: 
5276              self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_COUNT }) 
5277          return self.__field_hdr.getvalue() 
5278   
5279 -    def __setfield_hdr(self, value): 
5280          if isinstance(value,ss_cmd_hdr): 
5281              self.__field_hdr=value 
5282          else: 
5283              self.__field_hdr=ss_cmd_hdr(value,**{ 'command': SS_CMD_PB_COUNT }) 
5284   
5285 -    def __delfield_hdr(self): del self.__field_hdr 
5286   
5287      hdr=property(__getfield_hdr, __setfield_hdr, __delfield_hdr, None) 
5288   
5289 -    def iscontainer(self): 
5290          return True 
5291   
5292 -    def containerelements(self): 
5293          yield ('hdr', self.__field_hdr, None) 
5294   
5295   
5296   
5297   
5298 -class ss_pb_count_resp(BaseProtogenClass): 
5299      # Read-From-Buffer-Only Class 
5300      __fields=['hdr', 'count'] 
5301   
5302 -    def __init__(self, *args, **kwargs): 
5303          dict={} 
5304          # What was supplied to this function 
5305          dict.update(kwargs) 
5306          # Parent constructor 
5307          super(ss_pb_count_resp,self).__init__(**dict) 
5308          if self.__class__ is ss_pb_count_resp: 
5309              self._update(args,dict) 
5310   
5311   
5312 -    def getfields(self): 
5313          return self.__fields 
5314   
5315   
5316 -    def _update(self, args, kwargs): 
5317          super(ss_pb_count_resp,self)._update(args,kwargs) 
5318          keys=kwargs.keys() 
5319          for key in keys: 
5320              if key in self.__fields: 
5321                  setattr(self, key, kwargs[key]) 
5322                  del kwargs[key] 
5323          # Were any unrecognized kwargs passed in? 
5324          if __debug__: 
5325              self._complainaboutunusedargs(ss_pb_count_resp,kwargs) 
5326          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
5327          # Make all P fields that haven't already been constructed 
5328   
5329   
5330 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
5331          'Writes this packet to the supplied buffer' 
5332          raise NotImplementedError 
5333   
5334   
5335 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
5336          'Reads this packet from the supplied buffer' 
5337          self._bufferstartoffset=buf.getcurrentoffset() 
5338          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
5339          self.__field_hdr=ss_cmd_hdr() 
5340          self.__field_hdr.readfrombuffer(buf) 
5341          DONTCARE(**{'sizeinbytes': 1}).readfrombuffer(buf) 
5342          self.__field_count=UINT(**{'sizeinbytes': 2}) 
5343          self.__field_count.readfrombuffer(buf) 
5344          self._bufferendoffset=buf.getcurrentoffset() 
5345   
5346   
5347 -    def __getfield_hdr(self): 
5348          return self.__field_hdr.getvalue() 
5349   
5350 -    def __setfield_hdr(self, value): 
5351          if isinstance(value,ss_cmd_hdr): 
5352              self.__field_hdr=value 
5353          else: 
5354              self.__field_hdr=ss_cmd_hdr(value,) 
5355   
5356 -    def __delfield_hdr(self): del self.__field_hdr 
5357   
5358      hdr=property(__getfield_hdr, __setfield_hdr, __delfield_hdr, None) 
5359   
5360 -    def __getfield_count(self): 
5361          return self.__field_count.getvalue() 
5362   
5363 -    def __setfield_count(self, value): 
5364          if isinstance(value,UINT): 
5365              self.__field_count=value 
5366          else: 
5367              self.__field_count=UINT(value,**{'sizeinbytes': 2}) 
5368   
5369 -    def __delfield_count(self): del self.__field_count 
5370   
5371      count=property(__getfield_count, __setfield_count, __delfield_count, None) 
5372   
5373 -    def iscontainer(self): 
5374          return True 
5375   
5376 -    def containerelements(self): 
5377          yield ('hdr', self.__field_hdr, None) 
5378          yield ('count', self.__field_count, None) 
5379   
5380   
5381   
5382   
5383 -class ss_pb_read_req(BaseProtogenClass): 
5384      __fields=['hdr', 'index'] 
5385   
5386 -    def __init__(self, *args, **kwargs): 
5387          dict={} 
5388          # What was supplied to this function 
5389          dict.update(kwargs) 
5390          # Parent constructor 
5391          super(ss_pb_read_req,self).__init__(**dict) 
5392          if self.__class__ is ss_pb_read_req: 
5393              self._update(args,dict) 
5394   
5395   
5396 -    def getfields(self): 
5397          return self.__fields 
5398   
5399   
5400 -    def _update(self, args, kwargs): 
5401          super(ss_pb_read_req,self)._update(args,kwargs) 
5402          keys=kwargs.keys() 
5403          for key in keys: 
5404              if key in self.__fields: 
5405                  setattr(self, key, kwargs[key]) 
5406                  del kwargs[key] 
5407          # Were any unrecognized kwargs passed in? 
5408          if __debug__: 
5409              self._complainaboutunusedargs(ss_pb_read_req,kwargs) 
5410          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
5411          # Make all P fields that haven't already been constructed 
5412   
5413   
5414 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
5415          'Writes this packet to the supplied buffer' 
5416          self._bufferstartoffset=buf.getcurrentoffset() 
5417          try: self.__field_hdr 
5418          except: 
5419              self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_READ }) 
5420          self.__field_hdr.writetobuffer(buf) 
5421          try: self.__field__gen_p_samsungscha950_460 
5422          except: 
5423              self.__field__gen_p_samsungscha950_460=DONTCARE(**{'sizeinbytes': 1}) 
5424          self.__field__gen_p_samsungscha950_460.writetobuffer(buf) 
5425          self.__field_index.writetobuffer(buf) 
5426          self._bufferendoffset=buf.getcurrentoffset() 
5427          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
5428   
5429   
5430 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
5431          'Reads this packet from the supplied buffer' 
5432          self._bufferstartoffset=buf.getcurrentoffset() 
5433          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
5434          self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_READ }) 
5435          self.__field_hdr.readfrombuffer(buf) 
5436          self.__field__gen_p_samsungscha950_460=DONTCARE(**{'sizeinbytes': 1}) 
5437          self.__field__gen_p_samsungscha950_460.readfrombuffer(buf) 
5438          self.__field_index=UINT(**{'sizeinbytes': 2}) 
5439          self.__field_index.readfrombuffer(buf) 
5440          self._bufferendoffset=buf.getcurrentoffset() 
5441   
5442   
5443 -    def __getfield_hdr(self): 
5444          try: self.__field_hdr 
5445          except: 
5446              self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_READ }) 
5447          return self.__field_hdr.getvalue() 
5448   
5449 -    def __setfield_hdr(self, value): 
5450          if isinstance(value,ss_cmd_hdr): 
5451              self.__field_hdr=value 
5452          else: 
5453              self.__field_hdr=ss_cmd_hdr(value,**{ 'command': SS_CMD_PB_READ }) 
5454   
5455 -    def __delfield_hdr(self): del self.__field_hdr 
5456   
5457      hdr=property(__getfield_hdr, __setfield_hdr, __delfield_hdr, None) 
5458   
5459 -    def __getfield_index(self): 
5460          return self.__field_index.getvalue() 
5461   
5462 -    def __setfield_index(self, value): 
5463          if isinstance(value,UINT): 
5464              self.__field_index=value 
5465          else: 
5466              self.__field_index=UINT(value,**{'sizeinbytes': 2}) 
5467   
5468 -    def __delfield_index(self): del self.__field_index 
5469   
5470      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
5471   
5472 -    def iscontainer(self): 
5473          return True 
5474   
5475 -    def containerelements(self): 
5476          yield ('hdr', self.__field_hdr, None) 
5477          yield ('index', self.__field_index, None) 
5478   
5479   
5480   
5481   
5482 -class ss_pb_read_resp(BaseProtogenClass): 
5483      # Read-From-Buffer-Only Class 
5484      __fields=['hdr', 'index', 'data'] 
5485   
5486 -    def __init__(self, *args, **kwargs): 
5487          dict={} 
5488          # What was supplied to this function 
5489          dict.update(kwargs) 
5490          # Parent constructor 
5491          super(ss_pb_read_resp,self).__init__(**dict) 
5492          if self.__class__ is ss_pb_read_resp: 
5493              self._update(args,dict) 
5494   
5495   
5496 -    def getfields(self): 
5497          return self.__fields 
5498   
5499   
5500 -    def _update(self, args, kwargs): 
5501          super(ss_pb_read_resp,self)._update(args,kwargs) 
5502          keys=kwargs.keys() 
5503          for key in keys: 
5504              if key in self.__fields: 
5505                  setattr(self, key, kwargs[key]) 
5506                  del kwargs[key] 
5507          # Were any unrecognized kwargs passed in? 
5508          if __debug__: 
5509              self._complainaboutunusedargs(ss_pb_read_resp,kwargs) 
5510          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
5511          # Make all P fields that haven't already been constructed 
5512   
5513   
5514 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
5515          'Writes this packet to the supplied buffer' 
5516          raise NotImplementedError 
5517   
5518   
5519 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
5520          'Reads this packet from the supplied buffer' 
5521          self._bufferstartoffset=buf.getcurrentoffset() 
5522          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
5523          self.__field_hdr=ss_cmd_hdr() 
5524          self.__field_hdr.readfrombuffer(buf) 
5525          DONTCARE(**{'sizeinbytes': 1}).readfrombuffer(buf) 
5526          self.__field_index=UINT(**{'sizeinbytes': 2}) 
5527          self.__field_index.readfrombuffer(buf) 
5528          DONTCARE(**{'sizeinbytes': 1}).readfrombuffer(buf) 
5529          self.__field_data=DATA() 
5530          self.__field_data.readfrombuffer(buf) 
5531          self._bufferendoffset=buf.getcurrentoffset() 
5532   
5533   
5534 -    def __getfield_hdr(self): 
5535          return self.__field_hdr.getvalue() 
5536   
5537 -    def __setfield_hdr(self, value): 
5538          if isinstance(value,ss_cmd_hdr): 
5539              self.__field_hdr=value 
5540          else: 
5541              self.__field_hdr=ss_cmd_hdr(value,) 
5542   
5543 -    def __delfield_hdr(self): del self.__field_hdr 
5544   
5545      hdr=property(__getfield_hdr, __setfield_hdr, __delfield_hdr, None) 
5546   
5547 -    def __getfield_index(self): 
5548          return self.__field_index.getvalue() 
5549   
5550 -    def __setfield_index(self, value): 
5551          if isinstance(value,UINT): 
5552              self.__field_index=value 
5553          else: 
5554              self.__field_index=UINT(value,**{'sizeinbytes': 2}) 
5555   
5556 -    def __delfield_index(self): del self.__field_index 
5557   
5558      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
5559   
5560 -    def __getfield_data(self): 
5561          return self.__field_data.getvalue() 
5562   
5563 -    def __setfield_data(self, value): 
5564          if isinstance(value,DATA): 
5565              self.__field_data=value 
5566          else: 
5567              self.__field_data=DATA(value,) 
5568   
5569 -    def __delfield_data(self): del self.__field_data 
5570   
5571      data=property(__getfield_data, __setfield_data, __delfield_data, None) 
5572   
5573 -    def iscontainer(self): 
5574          return True 
5575   
5576 -    def containerelements(self): 
5577          yield ('hdr', self.__field_hdr, None) 
5578          yield ('index', self.__field_index, None) 
5579          yield ('data', self.__field_data, None) 
5580   
5581   
5582   
5583   
5584 -class ss_pb_voicemail_read_req(BaseProtogenClass): 
5585      __fields=['hdr', 'param'] 
5586   
5587 -    def __init__(self, *args, **kwargs): 
5588          dict={} 
5589          # What was supplied to this function 
5590          dict.update(kwargs) 
5591          # Parent constructor 
5592          super(ss_pb_voicemail_read_req,self).__init__(**dict) 
5593          if self.__class__ is ss_pb_voicemail_read_req: 
5594              self._update(args,dict) 
5595   
5596   
5597 -    def getfields(self): 
5598          return self.__fields 
5599   
5600   
5601 -    def _update(self, args, kwargs): 
5602          super(ss_pb_voicemail_read_req,self)._update(args,kwargs) 
5603          keys=kwargs.keys() 
5604          for key in keys: 
5605              if key in self.__fields: 
5606                  setattr(self, key, kwargs[key]) 
5607                  del kwargs[key] 
5608          # Were any unrecognized kwargs passed in? 
5609          if __debug__: 
5610              self._complainaboutunusedargs(ss_pb_voicemail_read_req,kwargs) 
5611          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
5612          # Make all P fields that haven't already been constructed 
5613   
5614   
5615 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
5616          'Writes this packet to the supplied buffer' 
5617          self._bufferstartoffset=buf.getcurrentoffset() 
5618          try: self.__field_hdr 
5619          except: 
5620              self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_VOICEMAIL_READ }) 
5621          self.__field_hdr.writetobuffer(buf) 
5622          try: self.__field_param 
5623          except: 
5624              self.__field_param=UINT(**{'sizeinbytes': 1,  'constant': SS_CMD_PB_VOICEMAIL_PARAM }) 
5625          self.__field_param.writetobuffer(buf) 
5626          self._bufferendoffset=buf.getcurrentoffset() 
5627          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
5628   
5629   
5630 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
5631          'Reads this packet from the supplied buffer' 
5632          self._bufferstartoffset=buf.getcurrentoffset() 
5633          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
5634          self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_VOICEMAIL_READ }) 
5635          self.__field_hdr.readfrombuffer(buf) 
5636          self.__field_param=UINT(**{'sizeinbytes': 1,  'constant': SS_CMD_PB_VOICEMAIL_PARAM }) 
5637          self.__field_param.readfrombuffer(buf) 
5638          self._bufferendoffset=buf.getcurrentoffset() 
5639   
5640   
5641 -    def __getfield_hdr(self): 
5642          try: self.__field_hdr 
5643          except: 
5644              self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_VOICEMAIL_READ }) 
5645          return self.__field_hdr.getvalue() 
5646   
5647 -    def __setfield_hdr(self, value): 
5648          if isinstance(value,ss_cmd_hdr): 
5649              self.__field_hdr=value 
5650          else: 
5651              self.__field_hdr=ss_cmd_hdr(value,**{ 'command': SS_CMD_PB_VOICEMAIL_READ }) 
5652   
5653 -    def __delfield_hdr(self): del self.__field_hdr 
5654   
5655      hdr=property(__getfield_hdr, __setfield_hdr, __delfield_hdr, None) 
5656   
5657 -    def __getfield_param(self): 
5658          try: self.__field_param 
5659          except: 
5660              self.__field_param=UINT(**{'sizeinbytes': 1,  'constant': SS_CMD_PB_VOICEMAIL_PARAM }) 
5661          return self.__field_param.getvalue() 
5662   
5663 -    def __setfield_param(self, value): 
5664          if isinstance(value,UINT): 
5665              self.__field_param=value 
5666          else: 
5667              self.__field_param=UINT(value,**{'sizeinbytes': 1,  'constant': SS_CMD_PB_VOICEMAIL_PARAM }) 
5668   
5669 -    def __delfield_param(self): del self.__field_param 
5670   
5671      param=property(__getfield_param, __setfield_param, __delfield_param, None) 
5672   
5673 -    def iscontainer(self): 
5674          return True 
5675   
5676 -    def containerelements(self): 
5677          yield ('hdr', self.__field_hdr, None) 
5678          yield ('param', self.__field_param, None) 
5679   
5680   
5681   
5682   
5683 -class ss_pb_voicemail_resp(BaseProtogenClass): 
5684      # Read-From-Buffer-Only Class 
5685      __fields=['hdr', 'param', 'number'] 
5686   
5687 -    def __init__(self, *args, **kwargs): 
5688          dict={} 
5689          # What was supplied to this function 
5690          dict.update(kwargs) 
5691          # Parent constructor 
5692          super(ss_pb_voicemail_resp,self).__init__(**dict) 
5693          if self.__class__ is ss_pb_voicemail_resp: 
5694              self._update(args,dict) 
5695   
5696   
5697 -    def getfields(self): 
5698          return self.__fields 
5699   
5700   
5701 -    def _update(self, args, kwargs): 
5702          super(ss_pb_voicemail_resp,self)._update(args,kwargs) 
5703          keys=kwargs.keys() 
5704          for key in keys: 
5705              if key in self.__fields: 
5706                  setattr(self, key, kwargs[key]) 
5707                  del kwargs[key] 
5708          # Were any unrecognized kwargs passed in? 
5709          if __debug__: 
5710              self._complainaboutunusedargs(ss_pb_voicemail_resp,kwargs) 
5711          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
5712          # Make all P fields that haven't already been constructed 
5713   
5714   
5715 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
5716          'Writes this packet to the supplied buffer' 
5717          raise NotImplementedError 
5718   
5719   
5720 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
5721          'Reads this packet from the supplied buffer' 
5722          self._bufferstartoffset=buf.getcurrentoffset() 
5723          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
5724          self.__field_hdr=ss_cmd_hdr() 
5725          self.__field_hdr.readfrombuffer(buf) 
5726          self.__field_param=UINT(**{'sizeinbytes': 1}) 
5727          self.__field_param.readfrombuffer(buf) 
5728          self.__field_number=STRING(**{ 'terminator': 0 }) 
5729          self.__field_number.readfrombuffer(buf) 
5730          self._bufferendoffset=buf.getcurrentoffset() 
5731   
5732   
5733 -    def __getfield_hdr(self): 
5734          return self.__field_hdr.getvalue() 
5735   
5736 -    def __setfield_hdr(self, value): 
5737          if isinstance(value,ss_cmd_hdr): 
5738              self.__field_hdr=value 
5739          else: 
5740              self.__field_hdr=ss_cmd_hdr(value,) 
5741   
5742 -    def __delfield_hdr(self): del self.__field_hdr 
5743   
5744      hdr=property(__getfield_hdr, __setfield_hdr, __delfield_hdr, None) 
5745   
5746 -    def __getfield_param(self): 
5747          return self.__field_param.getvalue() 
5748   
5749 -    def __setfield_param(self, value): 
5750          if isinstance(value,UINT): 
5751              self.__field_param=value 
5752          else: 
5753              self.__field_param=UINT(value,**{'sizeinbytes': 1}) 
5754   
5755 -    def __delfield_param(self): del self.__field_param 
5756   
5757      param=property(__getfield_param, __setfield_param, __delfield_param, None) 
5758   
5759 -    def __getfield_number(self): 
5760          return self.__field_number.getvalue() 
5761   
5762 -    def __setfield_number(self, value): 
5763          if isinstance(value,STRING): 
5764              self.__field_number=value 
5765          else: 
5766              self.__field_number=STRING(value,**{ 'terminator': 0 }) 
5767   
5768 -    def __delfield_number(self): del self.__field_number 
5769   
5770      number=property(__getfield_number, __setfield_number, __delfield_number, None) 
5771   
5772 -    def iscontainer(self): 
5773          return True 
5774   
5775 -    def containerelements(self): 
5776          yield ('hdr', self.__field_hdr, None) 
5777          yield ('param', self.__field_param, None) 
5778          yield ('number', self.__field_number, None) 
5779   
5780   
5781   
5782   
5783 -class ss_pb_voicemail_write_req(BaseProtogenClass): 
5784      __fields=['hdr', 'param', 'number'] 
5785   
5786 -    def __init__(self, *args, **kwargs): 
5787          dict={} 
5788          # What was supplied to this function 
5789          dict.update(kwargs) 
5790          # Parent constructor 
5791          super(ss_pb_voicemail_write_req,self).__init__(**dict) 
5792          if self.__class__ is ss_pb_voicemail_write_req: 
5793              self._update(args,dict) 
5794   
5795   
5796 -    def getfields(self): 
5797          return self.__fields 
5798   
5799   
5800 -    def _update(self, args, kwargs): 
5801          super(ss_pb_voicemail_write_req,self)._update(args,kwargs) 
5802          keys=kwargs.keys() 
5803          for key in keys: 
5804              if key in self.__fields: 
5805                  setattr(self, key, kwargs[key]) 
5806                  del kwargs[key] 
5807          # Were any unrecognized kwargs passed in? 
5808          if __debug__: 
5809              self._complainaboutunusedargs(ss_pb_voicemail_write_req,kwargs) 
5810          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
5811          # Make all P fields that haven't already been constructed 
5812   
5813   
5814 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
5815          'Writes this packet to the supplied buffer' 
5816          self._bufferstartoffset=buf.getcurrentoffset() 
5817          try: self.__field_hdr 
5818          except: 
5819              self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_VOICEMAIL_WRITE }) 
5820          self.__field_hdr.writetobuffer(buf) 
5821          try: self.__field_param 
5822          except: 
5823              self.__field_param=UINT(**{'sizeinbytes': 1,  'constant': SS_CMD_PB_VOICEMAIL_PARAM }) 
5824          self.__field_param.writetobuffer(buf) 
5825          try: self.__field_number 
5826          except: 
5827              self.__field_number=STRING(**{ 'terminator': 0,               'default': PB_DEFAULT_VOICEMAIL_NUMBER }) 
5828          self.__field_number.writetobuffer(buf) 
5829          self._bufferendoffset=buf.getcurrentoffset() 
5830          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
5831   
5832   
5833 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
5834          'Reads this packet from the supplied buffer' 
5835          self._bufferstartoffset=buf.getcurrentoffset() 
5836          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
5837          self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_VOICEMAIL_WRITE }) 
5838          self.__field_hdr.readfrombuffer(buf) 
5839          self.__field_param=UINT(**{'sizeinbytes': 1,  'constant': SS_CMD_PB_VOICEMAIL_PARAM }) 
5840          self.__field_param.readfrombuffer(buf) 
5841          self.__field_number=STRING(**{ 'terminator': 0,               'default': PB_DEFAULT_VOICEMAIL_NUMBER }) 
5842          self.__field_number.readfrombuffer(buf) 
5843          self._bufferendoffset=buf.getcurrentoffset() 
5844   
5845   
5846 -    def __getfield_hdr(self): 
5847          try: self.__field_hdr 
5848          except: 
5849              self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_VOICEMAIL_WRITE }) 
5850          return self.__field_hdr.getvalue() 
5851   
5852 -    def __setfield_hdr(self, value): 
5853          if isinstance(value,ss_cmd_hdr): 
5854              self.__field_hdr=value 
5855          else: 
5856              self.__field_hdr=ss_cmd_hdr(value,**{ 'command': SS_CMD_PB_VOICEMAIL_WRITE }) 
5857   
5858 -    def __delfield_hdr(self): del self.__field_hdr 
5859   
5860      hdr=property(__getfield_hdr, __setfield_hdr, __delfield_hdr, None) 
5861   
5862 -    def __getfield_param(self): 
5863          try: self.__field_param 
5864          except: 
5865              self.__field_param=UINT(**{'sizeinbytes': 1,  'constant': SS_CMD_PB_VOICEMAIL_PARAM }) 
5866          return self.__field_param.getvalue() 
5867   
5868 -    def __setfield_param(self, value): 
5869          if isinstance(value,UINT): 
5870              self.__field_param=value 
5871          else: 
5872              self.__field_param=UINT(value,**{'sizeinbytes': 1,  'constant': SS_CMD_PB_VOICEMAIL_PARAM }) 
5873   
5874 -    def __delfield_param(self): del self.__field_param 
5875   
5876      param=property(__getfield_param, __setfield_param, __delfield_param, None) 
5877   
5878 -    def __getfield_number(self): 
5879          try: self.__field_number 
5880          except: 
5881              self.__field_number=STRING(**{ 'terminator': 0,               'default': PB_DEFAULT_VOICEMAIL_NUMBER }) 
5882          return self.__field_number.getvalue() 
5883   
5884 -    def __setfield_number(self, value): 
5885          if isinstance(value,STRING): 
5886              self.__field_number=value 
5887          else: 
5888              self.__field_number=STRING(value,**{ 'terminator': 0,               'default': PB_DEFAULT_VOICEMAIL_NUMBER }) 
5889   
5890 -    def __delfield_number(self): del self.__field_number 
5891   
5892      number=property(__getfield_number, __setfield_number, __delfield_number, None) 
5893   
5894 -    def iscontainer(self): 
5895          return True 
5896   
5897 -    def containerelements(self): 
5898          yield ('hdr', self.__field_hdr, None) 
5899          yield ('param', self.__field_param, None) 
5900          yield ('number', self.__field_number, None) 
5901   
5902   
5903   
5904   
5905 -class ss_pb_clear_req(BaseProtogenClass): 
5906      __fields=['hdr'] 
5907   
5908 -    def __init__(self, *args, **kwargs): 
5909          dict={} 
5910          # What was supplied to this function 
5911          dict.update(kwargs) 
5912          # Parent constructor 
5913          super(ss_pb_clear_req,self).__init__(**dict) 
5914          if self.__class__ is ss_pb_clear_req: 
5915              self._update(args,dict) 
5916   
5917   
5918 -    def getfields(self): 
5919          return self.__fields 
5920   
5921   
5922 -    def _update(self, args, kwargs): 
5923          super(ss_pb_clear_req,self)._update(args,kwargs) 
5924          keys=kwargs.keys() 
5925          for key in keys: 
5926              if key in self.__fields: 
5927                  setattr(self, key, kwargs[key]) 
5928                  del kwargs[key] 
5929          # Were any unrecognized kwargs passed in? 
5930          if __debug__: 
5931              self._complainaboutunusedargs(ss_pb_clear_req,kwargs) 
5932          if len(args): 
5933              dict2={ 'command': SS_CMD_PB_CLEAR } 
5934              dict2.update(kwargs) 
5935              kwargs=dict2 
5936              self.__field_hdr=ss_cmd_hdr(*args,**dict2) 
5937          # Make all P fields that haven't already been constructed 
5938   
5939   
5940 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
5941          'Writes this packet to the supplied buffer' 
5942          self._bufferstartoffset=buf.getcurrentoffset() 
5943          try: self.__field_hdr 
5944          except: 
5945              self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_CLEAR }) 
5946          self.__field_hdr.writetobuffer(buf) 
5947          self._bufferendoffset=buf.getcurrentoffset() 
5948          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
5949   
5950   
5951 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
5952          'Reads this packet from the supplied buffer' 
5953          self._bufferstartoffset=buf.getcurrentoffset() 
5954          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
5955          self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_CLEAR }) 
5956          self.__field_hdr.readfrombuffer(buf) 
5957          self._bufferendoffset=buf.getcurrentoffset() 
5958   
5959   
5960 -    def __getfield_hdr(self): 
5961          try: self.__field_hdr 
5962          except: 
5963              self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_CLEAR }) 
5964          return self.__field_hdr.getvalue() 
5965   
5966 -    def __setfield_hdr(self, value): 
5967          if isinstance(value,ss_cmd_hdr): 
5968              self.__field_hdr=value 
5969          else: 
5970              self.__field_hdr=ss_cmd_hdr(value,**{ 'command': SS_CMD_PB_CLEAR }) 
5971   
5972 -    def __delfield_hdr(self): del self.__field_hdr 
5973   
5974      hdr=property(__getfield_hdr, __setfield_hdr, __delfield_hdr, None) 
5975   
5976 -    def iscontainer(self): 
5977          return True 
5978   
5979 -    def containerelements(self): 
5980          yield ('hdr', self.__field_hdr, None) 
5981   
5982   
5983   
5984   
5985 -class ss_pb_clear_resp(BaseProtogenClass): 
5986      # Read-From-Buffer-Only Class 
5987      __fields=['hdr', 'flg'] 
5988   
5989 -    def __init__(self, *args, **kwargs): 
5990          dict={} 
5991          # What was supplied to this function 
5992          dict.update(kwargs) 
5993          # Parent constructor 
5994          super(ss_pb_clear_resp,self).__init__(**dict) 
5995          if self.__class__ is ss_pb_clear_resp: 
5996              self._update(args,dict) 
5997   
5998   
5999 -    def getfields(self): 
6000          return self.__fields 
6001   
6002   
6003 -    def _update(self, args, kwargs): 
6004          super(ss_pb_clear_resp,self)._update(args,kwargs) 
6005          keys=kwargs.keys() 
6006          for key in keys: 
6007              if key in self.__fields: 
6008                  setattr(self, key, kwargs[key]) 
6009                  del kwargs[key] 
6010          # Were any unrecognized kwargs passed in? 
6011          if __debug__: 
6012              self._complainaboutunusedargs(ss_pb_clear_resp,kwargs) 
6013          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
6014          # Make all P fields that haven't already been constructed 
6015   
6016   
6017 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
6018          'Writes this packet to the supplied buffer' 
6019          raise NotImplementedError 
6020   
6021   
6022 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
6023          'Reads this packet from the supplied buffer' 
6024          self._bufferstartoffset=buf.getcurrentoffset() 
6025          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
6026          self.__field_hdr=ss_cmd_hdr() 
6027          self.__field_hdr.readfrombuffer(buf) 
6028          self.__field_flg=UINT(**{'sizeinbytes': 2}) 
6029          self.__field_flg.readfrombuffer(buf) 
6030          self._bufferendoffset=buf.getcurrentoffset() 
6031   
6032   
6033 -    def __getfield_hdr(self): 
6034          return self.__field_hdr.getvalue() 
6035   
6036 -    def __setfield_hdr(self, value): 
6037          if isinstance(value,ss_cmd_hdr): 
6038              self.__field_hdr=value 
6039          else: 
6040              self.__field_hdr=ss_cmd_hdr(value,) 
6041   
6042 -    def __delfield_hdr(self): del self.__field_hdr 
6043   
6044      hdr=property(__getfield_hdr, __setfield_hdr, __delfield_hdr, None) 
6045   
6046 -    def __getfield_flg(self): 
6047          return self.__field_flg.getvalue() 
6048   
6049 -    def __setfield_flg(self, value): 
6050          if isinstance(value,UINT): 
6051              self.__field_flg=value 
6052          else: 
6053              self.__field_flg=UINT(value,**{'sizeinbytes': 2}) 
6054   
6055 -    def __delfield_flg(self): del self.__field_flg 
6056   
6057      flg=property(__getfield_flg, __setfield_flg, __delfield_flg, None) 
6058   
6059 -    def iscontainer(self): 
6060          return True 
6061   
6062 -    def containerelements(self): 
6063          yield ('hdr', self.__field_hdr, None) 
6064          yield ('flg', self.__field_flg, None) 
6065   
6066   
6067   
6068   
6069 -class ss_number_entry(BaseProtogenClass): 
6070      __fields=['number', 'speeddial', 'primary', 'ringtone'] 
6071   
6072 -    def __init__(self, *args, **kwargs): 
6073          dict={} 
6074          # What was supplied to this function 
6075          dict.update(kwargs) 
6076          # Parent constructor 
6077          super(ss_number_entry,self).__init__(**dict) 
6078          if self.__class__ is ss_number_entry: 
6079              self._update(args,dict) 
6080   
6081   
6082 -    def getfields(self): 
6083          return self.__fields 
6084   
6085   
6086 -    def _update(self, args, kwargs): 
6087          super(ss_number_entry,self)._update(args,kwargs) 
6088          keys=kwargs.keys() 
6089          for key in keys: 
6090              if key in self.__fields: 
6091                  setattr(self, key, kwargs[key]) 
6092                  del kwargs[key] 
6093          # Were any unrecognized kwargs passed in? 
6094          if __debug__: 
6095              self._complainaboutunusedargs(ss_number_entry,kwargs) 
6096          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
6097          # Make all P fields that haven't already been constructed 
6098   
6099   
6100 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
6101          'Writes this packet to the supplied buffer' 
6102          self._bufferstartoffset=buf.getcurrentoffset() 
6103          try: self.__field_number 
6104          except: 
6105              self.__field_number=STRING(**{ 'terminator': 0,               'default': '',               'maxsizeinbytes': PB_MAX_NUMBER_LEN,               'raiseontruncate': False }) 
6106          self.__field_number.writetobuffer(buf) 
6107          try: self.__field_speeddial 
6108          except: 
6109              self.__field_speeddial=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
6110          self.__field_speeddial.writetobuffer(buf) 
6111          try: self.__field_primary 
6112          except: 
6113              self.__field_primary=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
6114          self.__field_primary.writetobuffer(buf) 
6115          try: self.__field__gen_p_samsungscha950_493 
6116          except: 
6117              self.__field__gen_p_samsungscha950_493=DONTCARE(**{'sizeinbytes': 8}) 
6118          self.__field__gen_p_samsungscha950_493.writetobuffer(buf) 
6119          try: self.__field_ringtone 
6120          except: 
6121              self.__field_ringtone=STRING(**{ 'terminator': 0,               'default': '' }) 
6122          self.__field_ringtone.writetobuffer(buf) 
6123          self._bufferendoffset=buf.getcurrentoffset() 
6124          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
6125   
6126   
6127 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
6128          'Reads this packet from the supplied buffer' 
6129          self._bufferstartoffset=buf.getcurrentoffset() 
6130          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
6131          self.__field_number=STRING(**{ 'terminator': 0,               'default': '',               'maxsizeinbytes': PB_MAX_NUMBER_LEN,               'raiseontruncate': False }) 
6132          self.__field_number.readfrombuffer(buf) 
6133          self.__field_speeddial=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
6134          self.__field_speeddial.readfrombuffer(buf) 
6135          self.__field_primary=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
6136          self.__field_primary.readfrombuffer(buf) 
6137          self.__field__gen_p_samsungscha950_493=DONTCARE(**{'sizeinbytes': 8}) 
6138          self.__field__gen_p_samsungscha950_493.readfrombuffer(buf) 
6139          self.__field_ringtone=STRING(**{ 'terminator': 0,               'default': '' }) 
6140          self.__field_ringtone.readfrombuffer(buf) 
6141          self._bufferendoffset=buf.getcurrentoffset() 
6142   
6143   
6144 -    def __getfield_number(self): 
6145          try: self.__field_number 
6146          except: 
6147              self.__field_number=STRING(**{ 'terminator': 0,               'default': '',               'maxsizeinbytes': PB_MAX_NUMBER_LEN,               'raiseontruncate': False }) 
6148          return self.__field_number.getvalue() 
6149   
6150 -    def __setfield_number(self, value): 
6151          if isinstance(value,STRING): 
6152              self.__field_number=value 
6153          else: 
6154              self.__field_number=STRING(value,**{ 'terminator': 0,               'default': '',               'maxsizeinbytes': PB_MAX_NUMBER_LEN,               'raiseontruncate': False }) 
6155   
6156 -    def __delfield_number(self): del self.__field_number 
6157   
6158      number=property(__getfield_number, __setfield_number, __delfield_number, None) 
6159   
6160 -    def __getfield_speeddial(self): 
6161          try: self.__field_speeddial 
6162          except: 
6163              self.__field_speeddial=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
6164          return self.__field_speeddial.getvalue() 
6165   
6166 -    def __setfield_speeddial(self, value): 
6167          if isinstance(value,UINT): 
6168              self.__field_speeddial=value 
6169          else: 
6170              self.__field_speeddial=UINT(value,**{'sizeinbytes': 2,  'default': 0 }) 
6171   
6172 -    def __delfield_speeddial(self): del self.__field_speeddial 
6173   
6174      speeddial=property(__getfield_speeddial, __setfield_speeddial, __delfield_speeddial, None) 
6175   
6176 -    def __getfield_primary(self): 
6177          try: self.__field_primary 
6178          except: 
6179              self.__field_primary=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
6180          return self.__field_primary.getvalue() 
6181   
6182 -    def __setfield_primary(self, value): 
6183          if isinstance(value,UINT): 
6184              self.__field_primary=value 
6185          else: 
6186              self.__field_primary=UINT(value,**{'sizeinbytes': 1,  'default': 0 }) 
6187   
6188 -    def __delfield_primary(self): del self.__field_primary 
6189   
6190      primary=property(__getfield_primary, __setfield_primary, __delfield_primary, None) 
6191   
6192 -    def __getfield_ringtone(self): 
6193          try: self.__field_ringtone 
6194          except: 
6195              self.__field_ringtone=STRING(**{ 'terminator': 0,               'default': '' }) 
6196          return self.__field_ringtone.getvalue() 
6197   
6198 -    def __setfield_ringtone(self, value): 
6199          if isinstance(value,STRING): 
6200              self.__field_ringtone=value 
6201          else: 
6202              self.__field_ringtone=STRING(value,**{ 'terminator': 0,               'default': '' }) 
6203   
6204 -    def __delfield_ringtone(self): del self.__field_ringtone 
6205   
6206      ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 
6207   
6208 -    def iscontainer(self): 
6209          return True 
6210   
6211 -    def containerelements(self): 
6212          yield ('number', self.__field_number, None) 
6213          yield ('speeddial', self.__field_speeddial, None) 
6214          yield ('primary', self.__field_primary, None) 
6215          yield ('ringtone', self.__field_ringtone, None) 
6216   
6217   
6218   
6219   
6220 -class ss_pb_entry(BaseProtogenClass): 
6221      __fields=['name', 'email', 'email2', 'wallpaper', 'home', 'work', 'cell', 'dummy', 'fax', 'cell2', 'group'] 
6222   
6223 -    def __init__(self, *args, **kwargs): 
6224          dict={} 
6225          # What was supplied to this function 
6226          dict.update(kwargs) 
6227          # Parent constructor 
6228          super(ss_pb_entry,self).__init__(**dict) 
6229          if self.__class__ is ss_pb_entry: 
6230              self._update(args,dict) 
6231   
6232   
6233 -    def getfields(self): 
6234          return self.__fields 
6235   
6236   
6237 -    def _update(self, args, kwargs): 
6238          super(ss_pb_entry,self)._update(args,kwargs) 
6239          keys=kwargs.keys() 
6240          for key in keys: 
6241              if key in self.__fields: 
6242                  setattr(self, key, kwargs[key]) 
6243                  del kwargs[key] 
6244          # Were any unrecognized kwargs passed in? 
6245          if __debug__: 
6246              self._complainaboutunusedargs(ss_pb_entry,kwargs) 
6247          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
6248          # Make all P fields that haven't already been constructed 
6249   
6250   
6251 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
6252          'Writes this packet to the supplied buffer' 
6253          self._bufferstartoffset=buf.getcurrentoffset() 
6254          self.__field_name.writetobuffer(buf) 
6255          try: self.__field_email 
6256          except: 
6257              self.__field_email=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'default': '',                'maxsizeinbytes': PB_MAX_EMAIL_LEN,                'raiseontruncate': False }) 
6258          self.__field_email.writetobuffer(buf) 
6259          try: self.__field_email2 
6260          except: 
6261              self.__field_email2=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'default': '',                'maxsizeinbytes': PB_MAX_EMAIL_LEN,                'raiseontruncate': False }) 
6262          self.__field_email2.writetobuffer(buf) 
6263          try: self.__field__gen_p_samsungscha950_512 
6264          except: 
6265              self.__field__gen_p_samsungscha950_512=DONTCARE(**{'sizeinbytes': 4}) 
6266          self.__field__gen_p_samsungscha950_512.writetobuffer(buf) 
6267          try: self.__field_wallpaper 
6268          except: 
6269              self.__field_wallpaper=STRING(**{ 'terminator': 0,               'default': '' }) 
6270          self.__field_wallpaper.writetobuffer(buf) 
6271          try: self.__field__gen_p_samsungscha950_515 
6272          except: 
6273              self.__field__gen_p_samsungscha950_515=DONTCARE(**{'sizeinbytes': 1}) 
6274          self.__field__gen_p_samsungscha950_515.writetobuffer(buf) 
6275          try: self.__field_home 
6276          except: 
6277              self.__field_home=ss_number_entry() 
6278          self.__field_home.writetobuffer(buf) 
6279          try: self.__field_work 
6280          except: 
6281              self.__field_work=ss_number_entry() 
6282          self.__field_work.writetobuffer(buf) 
6283          try: self.__field_cell 
6284          except: 
6285              self.__field_cell=ss_number_entry() 
6286          self.__field_cell.writetobuffer(buf) 
6287          try: self.__field_dummy 
6288          except: 
6289              self.__field_dummy=ss_number_entry() 
6290          self.__field_dummy.writetobuffer(buf) 
6291          try: self.__field_fax 
6292          except: 
6293              self.__field_fax=ss_number_entry() 
6294          self.__field_fax.writetobuffer(buf) 
6295          try: self.__field_cell2 
6296          except: 
6297              self.__field_cell2=ss_number_entry() 
6298          self.__field_cell2.writetobuffer(buf) 
6299          try: self.__field__gen_p_samsungscha950_522 
6300          except: 
6301              self.__field__gen_p_samsungscha950_522=DONTCARE(**{'sizeinbytes': 4}) 
6302          self.__field__gen_p_samsungscha950_522.writetobuffer(buf) 
6303          try: self.__field_group 
6304          except: 
6305              self.__field_group=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
6306          self.__field_group.writetobuffer(buf) 
6307          try: self.__field__gen_p_samsungscha950_524 
6308          except: 
6309              self.__field__gen_p_samsungscha950_524=DONTCARE(**{'sizeinbytes': 2}) 
6310          self.__field__gen_p_samsungscha950_524.writetobuffer(buf) 
6311          self._bufferendoffset=buf.getcurrentoffset() 
6312          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
6313   
6314   
6315 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
6316          'Reads this packet from the supplied buffer' 
6317          self._bufferstartoffset=buf.getcurrentoffset() 
6318          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
6319          self.__field_name=USTRING(**{ 'terminator': 0,                'maxsizeinbytes': PB_MAX_NAME_LEN,                'encoding': ENCODING,                'raiseontruncate': False }) 
6320          self.__field_name.readfrombuffer(buf) 
6321          self.__field_email=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'default': '',                'maxsizeinbytes': PB_MAX_EMAIL_LEN,                'raiseontruncate': False }) 
6322          self.__field_email.readfrombuffer(buf) 
6323          self.__field_email2=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'default': '',                'maxsizeinbytes': PB_MAX_EMAIL_LEN,                'raiseontruncate': False }) 
6324          self.__field_email2.readfrombuffer(buf) 
6325          self.__field__gen_p_samsungscha950_512=DONTCARE(**{'sizeinbytes': 4}) 
6326          self.__field__gen_p_samsungscha950_512.readfrombuffer(buf) 
6327          self.__field_wallpaper=STRING(**{ 'terminator': 0,               'default': '' }) 
6328          self.__field_wallpaper.readfrombuffer(buf) 
6329          self.__field__gen_p_samsungscha950_515=DONTCARE(**{'sizeinbytes': 1}) 
6330          self.__field__gen_p_samsungscha950_515.readfrombuffer(buf) 
6331          self.__field_home=ss_number_entry() 
6332          self.__field_home.readfrombuffer(buf) 
6333          self.__field_work=ss_number_entry() 
6334          self.__field_work.readfrombuffer(buf) 
6335          self.__field_cell=ss_number_entry() 
6336          self.__field_cell.readfrombuffer(buf) 
6337          self.__field_dummy=ss_number_entry() 
6338          self.__field_dummy.readfrombuffer(buf) 
6339          self.__field_fax=ss_number_entry() 
6340          self.__field_fax.readfrombuffer(buf) 
6341          self.__field_cell2=ss_number_entry() 
6342          self.__field_cell2.readfrombuffer(buf) 
6343          self.__field__gen_p_samsungscha950_522=DONTCARE(**{'sizeinbytes': 4}) 
6344          self.__field__gen_p_samsungscha950_522.readfrombuffer(buf) 
6345          self.__field_group=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
6346          self.__field_group.readfrombuffer(buf) 
6347          self.__field__gen_p_samsungscha950_524=DONTCARE(**{'sizeinbytes': 2}) 
6348          self.__field__gen_p_samsungscha950_524.readfrombuffer(buf) 
6349          self._bufferendoffset=buf.getcurrentoffset() 
6350   
6351   
6352 -    def __getfield_name(self): 
6353          return self.__field_name.getvalue() 
6354   
6355 -    def __setfield_name(self, value): 
6356          if isinstance(value,USTRING): 
6357              self.__field_name=value 
6358          else: 
6359              self.__field_name=USTRING(value,**{ 'terminator': 0,                'maxsizeinbytes': PB_MAX_NAME_LEN,                'encoding': ENCODING,                'raiseontruncate': False }) 
6360   
6361 -    def __delfield_name(self): del self.__field_name 
6362   
6363      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
6364   
6365 -    def __getfield_email(self): 
6366          try: self.__field_email 
6367          except: 
6368              self.__field_email=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'default': '',                'maxsizeinbytes': PB_MAX_EMAIL_LEN,                'raiseontruncate': False }) 
6369          return self.__field_email.getvalue() 
6370   
6371 -    def __setfield_email(self, value): 
6372          if isinstance(value,USTRING): 
6373              self.__field_email=value 
6374          else: 
6375              self.__field_email=USTRING(value,**{ 'terminator': 0,                'encoding': ENCODING,                'default': '',                'maxsizeinbytes': PB_MAX_EMAIL_LEN,                'raiseontruncate': False }) 
6376   
6377 -    def __delfield_email(self): del self.__field_email 
6378   
6379      email=property(__getfield_email, __setfield_email, __delfield_email, None) 
6380   
6381 -    def __getfield_email2(self): 
6382          try: self.__field_email2 
6383          except: 
6384              self.__field_email2=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'default': '',                'maxsizeinbytes': PB_MAX_EMAIL_LEN,                'raiseontruncate': False }) 
6385          return self.__field_email2.getvalue() 
6386   
6387 -    def __setfield_email2(self, value): 
6388          if isinstance(value,USTRING): 
6389              self.__field_email2=value 
6390          else: 
6391              self.__field_email2=USTRING(value,**{ 'terminator': 0,                'encoding': ENCODING,                'default': '',                'maxsizeinbytes': PB_MAX_EMAIL_LEN,                'raiseontruncate': False }) 
6392   
6393 -    def __delfield_email2(self): del self.__field_email2 
6394   
6395      email2=property(__getfield_email2, __setfield_email2, __delfield_email2, None) 
6396   
6397 -    def __getfield_wallpaper(self): 
6398          try: self.__field_wallpaper 
6399          except: 
6400              self.__field_wallpaper=STRING(**{ 'terminator': 0,               'default': '' }) 
6401          return self.__field_wallpaper.getvalue() 
6402   
6403 -    def __setfield_wallpaper(self, value): 
6404          if isinstance(value,STRING): 
6405              self.__field_wallpaper=value 
6406          else: 
6407              self.__field_wallpaper=STRING(value,**{ 'terminator': 0,               'default': '' }) 
6408   
6409 -    def __delfield_wallpaper(self): del self.__field_wallpaper 
6410   
6411      wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None) 
6412   
6413 -    def __getfield_home(self): 
6414          try: self.__field_home 
6415          except: 
6416              self.__field_home=ss_number_entry() 
6417          return self.__field_home.getvalue() 
6418   
6419 -    def __setfield_home(self, value): 
6420          if isinstance(value,ss_number_entry): 
6421              self.__field_home=value 
6422          else: 
6423              self.__field_home=ss_number_entry(value,) 
6424   
6425 -    def __delfield_home(self): del self.__field_home 
6426   
6427      home=property(__getfield_home, __setfield_home, __delfield_home, None) 
6428   
6429 -    def __getfield_work(self): 
6430          try: self.__field_work 
6431          except: 
6432              self.__field_work=ss_number_entry() 
6433          return self.__field_work.getvalue() 
6434   
6435 -    def __setfield_work(self, value): 
6436          if isinstance(value,ss_number_entry): 
6437              self.__field_work=value 
6438          else: 
6439              self.__field_work=ss_number_entry(value,) 
6440   
6441 -    def __delfield_work(self): del self.__field_work 
6442   
6443      work=property(__getfield_work, __setfield_work, __delfield_work, None) 
6444   
6445 -    def __getfield_cell(self): 
6446          try: self.__field_cell 
6447          except: 
6448              self.__field_cell=ss_number_entry() 
6449          return self.__field_cell.getvalue() 
6450   
6451 -    def __setfield_cell(self, value): 
6452          if isinstance(value,ss_number_entry): 
6453              self.__field_cell=value 
6454          else: 
6455              self.__field_cell=ss_number_entry(value,) 
6456   
6457 -    def __delfield_cell(self): del self.__field_cell 
6458   
6459      cell=property(__getfield_cell, __setfield_cell, __delfield_cell, None) 
6460   
6461 -    def __getfield_dummy(self): 
6462          try: self.__field_dummy 
6463          except: 
6464              self.__field_dummy=ss_number_entry() 
6465          return self.__field_dummy.getvalue() 
6466   
6467 -    def __setfield_dummy(self, value): 
6468          if isinstance(value,ss_number_entry): 
6469              self.__field_dummy=value 
6470          else: 
6471              self.__field_dummy=ss_number_entry(value,) 
6472   
6473 -    def __delfield_dummy(self): del self.__field_dummy 
6474   
6475      dummy=property(__getfield_dummy, __setfield_dummy, __delfield_dummy, None) 
6476   
6477 -    def __getfield_fax(self): 
6478          try: self.__field_fax 
6479          except: 
6480              self.__field_fax=ss_number_entry() 
6481          return self.__field_fax.getvalue() 
6482   
6483 -    def __setfield_fax(self, value): 
6484          if isinstance(value,ss_number_entry): 
6485              self.__field_fax=value 
6486          else: 
6487              self.__field_fax=ss_number_entry(value,) 
6488   
6489 -    def __delfield_fax(self): del self.__field_fax 
6490   
6491      fax=property(__getfield_fax, __setfield_fax, __delfield_fax, None) 
6492   
6493 -    def __getfield_cell2(self): 
6494          try: self.__field_cell2 
6495          except: 
6496              self.__field_cell2=ss_number_entry() 
6497          return self.__field_cell2.getvalue() 
6498   
6499 -    def __setfield_cell2(self, value): 
6500          if isinstance(value,ss_number_entry): 
6501              self.__field_cell2=value 
6502          else: 
6503              self.__field_cell2=ss_number_entry(value,) 
6504   
6505 -    def __delfield_cell2(self): del self.__field_cell2 
6506   
6507      cell2=property(__getfield_cell2, __setfield_cell2, __delfield_cell2, None) 
6508   
6509 -    def __getfield_group(self): 
6510          try: self.__field_group 
6511          except: 
6512              self.__field_group=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
6513          return self.__field_group.getvalue() 
6514   
6515 -    def __setfield_group(self, value): 
6516          if isinstance(value,UINT): 
6517              self.__field_group=value 
6518          else: 
6519              self.__field_group=UINT(value,**{'sizeinbytes': 1,  'default': 0 }) 
6520   
6521 -    def __delfield_group(self): del self.__field_group 
6522   
6523      group=property(__getfield_group, __setfield_group, __delfield_group, None) 
6524   
6525 -    def iscontainer(self): 
6526          return True 
6527   
6528 -    def containerelements(self): 
6529          yield ('name', self.__field_name, None) 
6530          yield ('email', self.__field_email, None) 
6531          yield ('email2', self.__field_email2, None) 
6532          yield ('wallpaper', self.__field_wallpaper, None) 
6533          yield ('home', self.__field_home, None) 
6534          yield ('work', self.__field_work, None) 
6535          yield ('cell', self.__field_cell, None) 
6536          yield ('dummy', self.__field_dummy, None) 
6537          yield ('fax', self.__field_fax, None) 
6538          yield ('cell2', self.__field_cell2, None) 
6539          yield ('group', self.__field_group, None) 
6540   
6541   
6542   
6543   
6544 -class ss_pb_write_req(BaseProtogenClass): 
6545      __fields=['hdr', 'zero', 'entry'] 
6546   
6547 -    def __init__(self, *args, **kwargs): 
6548          dict={} 
6549          # What was supplied to this function 
6550          dict.update(kwargs) 
6551          # Parent constructor 
6552          super(ss_pb_write_req,self).__init__(**dict) 
6553          if self.__class__ is ss_pb_write_req: 
6554              self._update(args,dict) 
6555   
6556   
6557 -    def getfields(self): 
6558          return self.__fields 
6559   
6560   
6561 -    def _update(self, args, kwargs): 
6562          super(ss_pb_write_req,self)._update(args,kwargs) 
6563          keys=kwargs.keys() 
6564          for key in keys: 
6565              if key in self.__fields: 
6566                  setattr(self, key, kwargs[key]) 
6567                  del kwargs[key] 
6568          # Were any unrecognized kwargs passed in? 
6569          if __debug__: 
6570              self._complainaboutunusedargs(ss_pb_write_req,kwargs) 
6571          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
6572          # Make all P fields that haven't already been constructed 
6573   
6574   
6575 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
6576          'Writes this packet to the supplied buffer' 
6577          self._bufferstartoffset=buf.getcurrentoffset() 
6578          try: self.__field_hdr 
6579          except: 
6580              self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_WRITE }) 
6581          self.__field_hdr.writetobuffer(buf) 
6582          try: self.__field_zero 
6583          except: 
6584              self.__field_zero=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
6585          self.__field_zero.writetobuffer(buf) 
6586          self.__field_entry.writetobuffer(buf) 
6587          self._bufferendoffset=buf.getcurrentoffset() 
6588          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
6589   
6590   
6591 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
6592          'Reads this packet from the supplied buffer' 
6593          self._bufferstartoffset=buf.getcurrentoffset() 
6594          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
6595          self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_WRITE }) 
6596          self.__field_hdr.readfrombuffer(buf) 
6597          self.__field_zero=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
6598          self.__field_zero.readfrombuffer(buf) 
6599          self.__field_entry=ss_pb_entry() 
6600          self.__field_entry.readfrombuffer(buf) 
6601          self._bufferendoffset=buf.getcurrentoffset() 
6602   
6603   
6604 -    def __getfield_hdr(self): 
6605          try: self.__field_hdr 
6606          except: 
6607              self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_WRITE }) 
6608          return self.__field_hdr.getvalue() 
6609   
6610 -    def __setfield_hdr(self, value): 
6611          if isinstance(value,ss_cmd_hdr): 
6612              self.__field_hdr=value 
6613          else: 
6614              self.__field_hdr=ss_cmd_hdr(value,**{ 'command': SS_CMD_PB_WRITE }) 
6615   
6616 -    def __delfield_hdr(self): del self.__field_hdr 
6617   
6618      hdr=property(__getfield_hdr, __setfield_hdr, __delfield_hdr, None) 
6619   
6620 -    def __getfield_zero(self): 
6621          try: self.__field_zero 
6622          except: 
6623              self.__field_zero=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
6624          return self.__field_zero.getvalue() 
6625   
6626 -    def __setfield_zero(self, value): 
6627          if isinstance(value,UINT): 
6628              self.__field_zero=value 
6629          else: 
6630              self.__field_zero=UINT(value,**{'sizeinbytes': 1,  'default': 0 }) 
6631   
6632 -    def __delfield_zero(self): del self.__field_zero 
6633   
6634      zero=property(__getfield_zero, __setfield_zero, __delfield_zero, None) 
6635   
6636 -    def __getfield_entry(self): 
6637          return self.__field_entry.getvalue() 
6638   
6639 -    def __setfield_entry(self, value): 
6640          if isinstance(value,ss_pb_entry): 
6641              self.__field_entry=value 
6642          else: 
6643              self.__field_entry=ss_pb_entry(value,) 
6644   
6645 -    def __delfield_entry(self): del self.__field_entry 
6646   
6647      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
6648   
6649 -    def iscontainer(self): 
6650          return True 
6651   
6652 -    def containerelements(self): 
6653          yield ('hdr', self.__field_hdr, None) 
6654          yield ('zero', self.__field_zero, None) 
6655          yield ('entry', self.__field_entry, None) 
6656   
6657   
6658   
6659   
6660 -class ss_pb_write_resp(BaseProtogenClass): 
6661      __fields=['hdr', 'index'] 
6662   
6663 -    def __init__(self, *args, **kwargs): 
6664          dict={} 
6665          # What was supplied to this function 
6666          dict.update(kwargs) 
6667          # Parent constructor 
6668          super(ss_pb_write_resp,self).__init__(**dict) 
6669          if self.__class__ is ss_pb_write_resp: 
6670              self._update(args,dict) 
6671   
6672   
6673 -    def getfields(self): 
6674          return self.__fields 
6675   
6676   
6677 -    def _update(self, args, kwargs): 
6678          super(ss_pb_write_resp,self)._update(args,kwargs) 
6679          keys=kwargs.keys() 
6680          for key in keys: 
6681              if key in self.__fields: 
6682                  setattr(self, key, kwargs[key]) 
6683                  del kwargs[key] 
6684          # Were any unrecognized kwargs passed in? 
6685          if __debug__: 
6686              self._complainaboutunusedargs(ss_pb_write_resp,kwargs) 
6687          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
6688          # Make all P fields that haven't already been constructed 
6689   
6690   
6691 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
6692          'Writes this packet to the supplied buffer' 
6693          self._bufferstartoffset=buf.getcurrentoffset() 
6694          self.__field_hdr.writetobuffer(buf) 
6695          self.__field__gen_p_samsungscha950_533.writetobuffer(buf) 
6696          self.__field_index.writetobuffer(buf) 
6697          self._bufferendoffset=buf.getcurrentoffset() 
6698          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
6699   
6700   
6701 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
6702          'Reads this packet from the supplied buffer' 
6703          self._bufferstartoffset=buf.getcurrentoffset() 
6704          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
6705          self.__field_hdr=ss_cmd_hdr() 
6706          self.__field_hdr.readfrombuffer(buf) 
6707          self.__field__gen_p_samsungscha950_533=DONTCARE(**{'sizeinbytes': 1}) 
6708          self.__field__gen_p_samsungscha950_533.readfrombuffer(buf) 
6709          self.__field_index=UINT(**{'sizeinbytes': 2}) 
6710          self.__field_index.readfrombuffer(buf) 
6711          self._bufferendoffset=buf.getcurrentoffset() 
6712   
6713   
6714 -    def __getfield_hdr(self): 
6715          return self.__field_hdr.getvalue() 
6716   
6717 -    def __setfield_hdr(self, value): 
6718          if isinstance(value,ss_cmd_hdr): 
6719              self.__field_hdr=value 
6720          else: 
6721              self.__field_hdr=ss_cmd_hdr(value,) 
6722   
6723 -    def __delfield_hdr(self): del self.__field_hdr 
6724   
6725      hdr=property(__getfield_hdr, __setfield_hdr, __delfield_hdr, None) 
6726   
6727 -    def __getfield_index(self): 
6728          return self.__field_index.getvalue() 
6729   
6730 -    def __setfield_index(self, value): 
6731          if isinstance(value,UINT): 
6732              self.__field_index=value 
6733          else: 
6734              self.__field_index=UINT(value,**{'sizeinbytes': 2}) 
6735   
6736 -    def __delfield_index(self): del self.__field_index 
6737   
6738      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
6739   
6740 -    def iscontainer(self): 
6741          return True 
6742   
6743 -    def containerelements(self): 
6744          yield ('hdr', self.__field_hdr, None) 
6745          yield ('index', self.__field_index, None) 
6746   
6747   
6748   
6749   
6750 -class cl_list(BaseProtogenClass): 
6751      # Read-From-Buffer-Only Class 
6752      __fields=['index'] 
6753   
6754 -    def __init__(self, *args, **kwargs): 
6755          dict={} 
6756          # What was supplied to this function 
6757          dict.update(kwargs) 
6758          # Parent constructor 
6759          super(cl_list,self).__init__(**dict) 
6760          if self.__class__ is cl_list: 
6761              self._update(args,dict) 
6762   
6763   
6764 -    def getfields(self): 
6765          return self.__fields 
6766   
6767   
6768 -    def _update(self, args, kwargs): 
6769          super(cl_list,self)._update(args,kwargs) 
6770          keys=kwargs.keys() 
6771          for key in keys: 
6772              if key in self.__fields: 
6773                  setattr(self, key, kwargs[key]) 
6774                  del kwargs[key] 
6775          # Were any unrecognized kwargs passed in? 
6776          if __debug__: 
6777              self._complainaboutunusedargs(cl_list,kwargs) 
6778          if len(args): 
6779              dict2={'sizeinbytes': 1} 
6780              dict2.update(kwargs) 
6781              kwargs=dict2 
6782              self.__field_index=UINT(*args,**dict2) 
6783          # Make all P fields that haven't already been constructed 
6784   
6785   
6786 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
6787          'Writes this packet to the supplied buffer' 
6788          raise NotImplementedError 
6789   
6790   
6791 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
6792          'Reads this packet from the supplied buffer' 
6793          self._bufferstartoffset=buf.getcurrentoffset() 
6794          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
6795          self.__field_index=UINT(**{'sizeinbytes': 1}) 
6796          self.__field_index.readfrombuffer(buf) 
6797          self._bufferendoffset=buf.getcurrentoffset() 
6798   
6799   
6800 -    def __getfield_index(self): 
6801          return self.__field_index.getvalue() 
6802   
6803 -    def __setfield_index(self, value): 
6804          if isinstance(value,UINT): 
6805              self.__field_index=value 
6806          else: 
6807              self.__field_index=UINT(value,**{'sizeinbytes': 1}) 
6808   
6809 -    def __delfield_index(self): del self.__field_index 
6810   
6811      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
6812   
6813 -    def iscontainer(self): 
6814          return True 
6815   
6816 -    def containerelements(self): 
6817          yield ('index', self.__field_index, None) 
6818   
6819   
6820   
6821   
6822 -class cl_index_file(BaseProtogenClass): 
6823      # Read-From-Buffer-Only Class 
6824      __fields=['incoming', 'outgoing', 'missed', 'incoming_count', 'outgoing_count', 'missed_count'] 
6825   
6826 -    def __init__(self, *args, **kwargs): 
6827          dict={} 
6828          # What was supplied to this function 
6829          dict.update(kwargs) 
6830          # Parent constructor 
6831          super(cl_index_file,self).__init__(**dict) 
6832          if self.__class__ is cl_index_file: 
6833              self._update(args,dict) 
6834   
6835   
6836 -    def getfields(self): 
6837          return self.__fields 
6838   
6839   
6840 -    def _update(self, args, kwargs): 
6841          super(cl_index_file,self)._update(args,kwargs) 
6842          keys=kwargs.keys() 
6843          for key in keys: 
6844              if key in self.__fields: 
6845                  setattr(self, key, kwargs[key]) 
6846                  del kwargs[key] 
6847          # Were any unrecognized kwargs passed in? 
6848          if __debug__: 
6849              self._complainaboutunusedargs(cl_index_file,kwargs) 
6850          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
6851          # Make all P fields that haven't already been constructed 
6852   
6853   
6854 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
6855          'Writes this packet to the supplied buffer' 
6856          raise NotImplementedError 
6857   
6858   
6859 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
6860          'Reads this packet from the supplied buffer' 
6861          self._bufferstartoffset=buf.getcurrentoffset() 
6862          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
6863          self.__field_incoming=LIST(**{ 'length': CL_MAX_ENTRIES,             'elementclass': cl_list }) 
6864          self.__field_incoming.readfrombuffer(buf) 
6865          self.__field_outgoing=LIST(**{ 'length': CL_MAX_ENTRIES,             'elementclass': cl_list }) 
6866          self.__field_outgoing.readfrombuffer(buf) 
6867          self.__field_missed=LIST(**{ 'length': CL_MAX_ENTRIES,             'elementclass': cl_list }) 
6868          self.__field_missed.readfrombuffer(buf) 
6869          DONTCARE(**{'sizeinbytes': 111}).readfrombuffer(buf) 
6870          self.__field_incoming_count=UINT(**{'sizeinbytes': 4}) 
6871          self.__field_incoming_count.readfrombuffer(buf) 
6872          self.__field_outgoing_count=UINT(**{'sizeinbytes': 4}) 
6873          self.__field_outgoing_count.readfrombuffer(buf) 
6874          self.__field_missed_count=UINT(**{'sizeinbytes': 4}) 
6875          self.__field_missed_count.readfrombuffer(buf) 
6876          self._bufferendoffset=buf.getcurrentoffset() 
6877   
6878   
6879 -    def __getfield_incoming(self): 
6880          return self.__field_incoming.getvalue() 
6881   
6882 -    def __setfield_incoming(self, value): 
6883          if isinstance(value,LIST): 
6884              self.__field_incoming=value 
6885          else: 
6886              self.__field_incoming=LIST(value,**{ 'length': CL_MAX_ENTRIES,             'elementclass': cl_list }) 
6887   
6888 -    def __delfield_incoming(self): del self.__field_incoming 
6889   
6890      incoming=property(__getfield_incoming, __setfield_incoming, __delfield_incoming, None) 
6891   
6892 -    def __getfield_outgoing(self): 
6893          return self.__field_outgoing.getvalue() 
6894   
6895 -    def __setfield_outgoing(self, value): 
6896          if isinstance(value,LIST): 
6897              self.__field_outgoing=value 
6898          else: 
6899              self.__field_outgoing=LIST(value,**{ 'length': CL_MAX_ENTRIES,             'elementclass': cl_list }) 
6900   
6901 -    def __delfield_outgoing(self): del self.__field_outgoing 
6902   
6903      outgoing=property(__getfield_outgoing, __setfield_outgoing, __delfield_outgoing, None) 
6904   
6905 -    def __getfield_missed(self): 
6906          return self.__field_missed.getvalue() 
6907   
6908 -    def __setfield_missed(self, value): 
6909          if isinstance(value,LIST): 
6910              self.__field_missed=value 
6911          else: 
6912              self.__field_missed=LIST(value,**{ 'length': CL_MAX_ENTRIES,             'elementclass': cl_list }) 
6913   
6914 -    def __delfield_missed(self): del self.__field_missed 
6915   
6916      missed=property(__getfield_missed, __setfield_missed, __delfield_missed, None) 
6917   
6918 -    def __getfield_incoming_count(self): 
6919          return self.__field_incoming_count.getvalue() 
6920   
6921 -    def __setfield_incoming_count(self, value): 
6922          if isinstance(value,UINT): 
6923              self.__field_incoming_count=value 
6924          else: 
6925              self.__field_incoming_count=UINT(value,**{'sizeinbytes': 4}) 
6926   
6927 -    def __delfield_incoming_count(self): del self.__field_incoming_count 
6928   
6929      incoming_count=property(__getfield_incoming_count, __setfield_incoming_count, __delfield_incoming_count, None) 
6930   
6931 -    def __getfield_outgoing_count(self): 
6932          return self.__field_outgoing_count.getvalue() 
6933   
6934 -    def __setfield_outgoing_count(self, value): 
6935          if isinstance(value,UINT): 
6936              self.__field_outgoing_count=value 
6937          else: 
6938              self.__field_outgoing_count=UINT(value,**{'sizeinbytes': 4}) 
6939   
6940 -    def __delfield_outgoing_count(self): del self.__field_outgoing_count 
6941   
6942      outgoing_count=property(__getfield_outgoing_count, __setfield_outgoing_count, __delfield_outgoing_count, None) 
6943   
6944 -    def __getfield_missed_count(self): 
6945          return self.__field_missed_count.getvalue() 
6946   
6947 -    def __setfield_missed_count(self, value): 
6948          if isinstance(value,UINT): 
6949              self.__field_missed_count=value 
6950          else: 
6951              self.__field_missed_count=UINT(value,**{'sizeinbytes': 4}) 
6952   
6953 -    def __delfield_missed_count(self): del self.__field_missed_count 
6954   
6955      missed_count=property(__getfield_missed_count, __setfield_missed_count, __delfield_missed_count, None) 
6956   
6957 -    def iscontainer(self): 
6958          return True 
6959   
6960 -    def containerelements(self): 
6961          yield ('incoming', self.__field_incoming, None) 
6962          yield ('outgoing', self.__field_outgoing, None) 
6963          yield ('missed', self.__field_missed, None) 
6964          yield ('incoming_count', self.__field_incoming_count, None) 
6965          yield ('outgoing_count', self.__field_outgoing_count, None) 
6966          yield ('missed_count', self.__field_missed_count, None) 
6967   
6968   
6969   
6970   
6971 -class cl_file(BaseProtogenClass): 
6972      # Read-From-Buffer-Only Class 
6973      __fields=['cl_type', 'number', 'datetime', 'duration'] 
6974   
6975 -    def __init__(self, *args, **kwargs): 
6976          dict={} 
6977          # What was supplied to this function 
6978          dict.update(kwargs) 
6979          # Parent constructor 
6980          super(cl_file,self).__init__(**dict) 
6981          if self.__class__ is cl_file: 
6982              self._update(args,dict) 
6983   
6984   
6985 -    def getfields(self): 
6986          return self.__fields 
6987   
6988   
6989 -    def _update(self, args, kwargs): 
6990          super(cl_file,self)._update(args,kwargs) 
6991          keys=kwargs.keys() 
6992          for key in keys: 
6993              if key in self.__fields: 
6994                  setattr(self, key, kwargs[key]) 
6995                  del kwargs[key] 
6996          # Were any unrecognized kwargs passed in? 
6997          if __debug__: 
6998              self._complainaboutunusedargs(cl_file,kwargs) 
6999          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
7000          # Make all P fields that haven't already been constructed 
7001   
7002   
7003 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
7004          'Writes this packet to the supplied buffer' 
7005          raise NotImplementedError 
7006   
7007   
7008 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
7009          'Reads this packet from the supplied buffer' 
7010          self._bufferstartoffset=buf.getcurrentoffset() 
7011          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
7012          self.__field_cl_type=UINT(**{'sizeinbytes': 1}) 
7013          self.__field_cl_type.readfrombuffer(buf) 
7014          self.__field_number=STRING(**{'sizeinbytes': 51,  'terminator': 0 }) 
7015          self.__field_number.readfrombuffer(buf) 
7016          self.__field_datetime=DateTime1(**{'sizeinbytes': 4}) 
7017          self.__field_datetime.readfrombuffer(buf) 
7018          DONTCARE(**{'sizeinbytes': 4}).readfrombuffer(buf) 
7019          self.__field_duration=UINT(**{'sizeinbytes': 4}) 
7020          self.__field_duration.readfrombuffer(buf) 
7021          self._bufferendoffset=buf.getcurrentoffset() 
7022   
7023   
7024 -    def __getfield_cl_type(self): 
7025          return self.__field_cl_type.getvalue() 
7026   
7027 -    def __setfield_cl_type(self, value): 
7028          if isinstance(value,UINT): 
7029              self.__field_cl_type=value 
7030          else: 
7031              self.__field_cl_type=UINT(value,**{'sizeinbytes': 1}) 
7032   
7033 -    def __delfield_cl_type(self): del self.__field_cl_type 
7034   
7035      cl_type=property(__getfield_cl_type, __setfield_cl_type, __delfield_cl_type, None) 
7036   
7037 -    def __getfield_number(self): 
7038          return self.__field_number.getvalue() 
7039   
7040 -    def __setfield_number(self, value): 
7041          if isinstance(value,STRING): 
7042              self.__field_number=value 
7043          else: 
7044              self.__field_number=STRING(value,**{'sizeinbytes': 51,  'terminator': 0 }) 
7045   
7046 -    def __delfield_number(self): del self.__field_number 
7047   
7048      number=property(__getfield_number, __setfield_number, __delfield_number, None) 
7049   
7050 -    def __getfield_datetime(self): 
7051          return self.__field_datetime.getvalue() 
7052   
7053 -    def __setfield_datetime(self, value): 
7054          if isinstance(value,DateTime1): 
7055              self.__field_datetime=value 
7056          else: 
7057              self.__field_datetime=DateTime1(value,**{'sizeinbytes': 4}) 
7058   
7059 -    def __delfield_datetime(self): del self.__field_datetime 
7060   
7061      datetime=property(__getfield_datetime, __setfield_datetime, __delfield_datetime, None) 
7062   
7063 -    def __getfield_duration(self): 
7064          return self.__field_duration.getvalue() 
7065   
7066 -    def __setfield_duration(self, value): 
7067          if isinstance(value,UINT): 
7068              self.__field_duration=value 
7069          else: 
7070              self.__field_duration=UINT(value,**{'sizeinbytes': 4}) 
7071   
7072 -    def __delfield_duration(self): del self.__field_duration 
7073   
7074      duration=property(__getfield_duration, __setfield_duration, __delfield_duration, None) 
7075   
7076 -    def iscontainer(self): 
7077          return True 
7078   
7079 -    def containerelements(self): 
7080          yield ('cl_type', self.__field_cl_type, None) 
7081          yield ('number', self.__field_number, None) 
7082          yield ('datetime', self.__field_datetime, None) 
7083          yield ('duration', self.__field_duration, None) 
7084   
7085      @property 
7086 -    def valid(self): 
7087          global CL_VALID_TYPE 
7088          return bool(self.cl_type in CL_VALID_TYPE and self.number) 
7089   
7090   
7091   
7092   
7093 -class pBOOL(BaseProtogenClass): 
7094      __fields=['value'] 
7095   
7096 -    def __init__(self, *args, **kwargs): 
7097          dict={} 
7098          # What was supplied to this function 
7099          dict.update(kwargs) 
7100          # Parent constructor 
7101          super(pBOOL,self).__init__(**dict) 
7102          if self.__class__ is pBOOL: 
7103              self._update(args,dict) 
7104   
7105   
7106 -    def getfields(self): 
7107          return self.__fields 
7108   
7109   
7110 -    def _update(self, args, kwargs): 
7111          super(pBOOL,self)._update(args,kwargs) 
7112          keys=kwargs.keys() 
7113          for key in keys: 
7114              if key in self.__fields: 
7115                  setattr(self, key, kwargs[key]) 
7116                  del kwargs[key] 
7117          # Were any unrecognized kwargs passed in? 
7118          if __debug__: 
7119              self._complainaboutunusedargs(pBOOL,kwargs) 
7120          if len(args): 
7121              dict2={'sizeinbytes': 'P'} 
7122              dict2.update(kwargs) 
7123              kwargs=dict2 
7124              self.__field_value=BOOL(*args,**dict2) 
7125          # Make all P fields that haven't already been constructed 
7126          try: self.__field_value 
7127          except: 
7128              self.__field_value=BOOL() 
7129   
7130   
7131 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
7132          'Writes this packet to the supplied buffer' 
7133          self._bufferstartoffset=buf.getcurrentoffset() 
7134          self._bufferendoffset=buf.getcurrentoffset() 
7135          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
7136   
7137   
7138 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
7139          'Reads this packet from the supplied buffer' 
7140          self._bufferstartoffset=buf.getcurrentoffset() 
7141          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
7142          self._bufferendoffset=buf.getcurrentoffset() 
7143   
7144   
7145 -    def __getfield_value(self): 
7146          return self.__field_value.getvalue() 
7147   
7148 -    def __setfield_value(self, value): 
7149          if isinstance(value,BOOL): 
7150              self.__field_value=value 
7151          else: 
7152              self.__field_value=BOOL(value,) 
7153   
7154 -    def __delfield_value(self): del self.__field_value 
7155   
7156      value=property(__getfield_value, __setfield_value, __delfield_value, None) 
7157   
7158 -    def iscontainer(self): 
7159          return True 
7160   
7161 -    def containerelements(self): 
7162          yield ('value', self.__field_value, None) 
7163   
7164   
7165   
7166   
7167 -class sms_header(BaseProtogenClass): 
7168      # Read-From-Buffer-Only Class 
7169      __fields=['index', 'msg_len', 'callback_len', 'bitmap1', 'bitmap2', 'body_len', 'file_type', 'msg_type', 'enhance_delivery', 'is_txt_msg', 'in_msg', 'sent_msg', 'draft_msg', 'body'] 
7170   
7171 -    def __init__(self, *args, **kwargs): 
7172          dict={} 
7173          # What was supplied to this function 
7174          dict.update(kwargs) 
7175          # Parent constructor 
7176          super(sms_header,self).__init__(**dict) 
7177          if self.__class__ is sms_header: 
7178              self._update(args,dict) 
7179   
7180   
7181 -    def getfields(self): 
7182          return self.__fields 
7183   
7184   
7185 -    def _update(self, args, kwargs): 
7186          super(sms_header,self)._update(args,kwargs) 
7187          keys=kwargs.keys() 
7188          for key in keys: 
7189              if key in self.__fields: 
7190                  setattr(self, key, kwargs[key]) 
7191                  del kwargs[key] 
7192          # Were any unrecognized kwargs passed in? 
7193          if __debug__: 
7194              self._complainaboutunusedargs(sms_header,kwargs) 
7195          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
7196          # Make all P fields that haven't already been constructed 
7197   
7198   
7199 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
7200          'Writes this packet to the supplied buffer' 
7201          raise NotImplementedError 
7202   
7203   
7204 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
7205          'Reads this packet from the supplied buffer' 
7206          self._bufferstartoffset=buf.getcurrentoffset() 
7207          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
7208          self.__field_index=UINT(**{'sizeinbytes': 2}) 
7209          self.__field_index.readfrombuffer(buf) 
7210          self.__field_msg_len=UINT(**{'sizeinbytes': 1}) 
7211          self.__field_msg_len.readfrombuffer(buf) 
7212          self.__field_callback_len=UINT(**{'sizeinbytes': 1}) 
7213          self.__field_callback_len.readfrombuffer(buf) 
7214          self.__field_bitmap1=UINT(**{'sizeinbytes': 1}) 
7215          self.__field_bitmap1.readfrombuffer(buf) 
7216          self.__field_bitmap2=UINT(**{'sizeinbytes': 1}) 
7217          self.__field_bitmap2.readfrombuffer(buf) 
7218          DONTCARE(**{'sizeinbytes': 6}).readfrombuffer(buf) 
7219          self.__field_body_len=UINT(**{'sizeinbytes': 2}) 
7220          self.__field_body_len.readfrombuffer(buf) 
7221          self.__field_file_type=UINT(**{'sizeinbytes': 2}) 
7222          self.__field_file_type.readfrombuffer(buf) 
7223          self.__field_msg_type=UINT(**{'sizeinbytes': 1}) 
7224          self.__field_msg_type.readfrombuffer(buf) 
7225          self.__field_enhance_delivery=UINT(**{'sizeinbytes': 1}) 
7226          self.__field_enhance_delivery.readfrombuffer(buf) 
7227          self.__field_is_txt_msg=pBOOL(**{ 'value': self.file_type==SMS_TXT_TYPE and self.msg_type in SMS_VALID_TYPE }) 
7228          self.__field_is_txt_msg.readfrombuffer(buf) 
7229          self.__field_in_msg=pBOOL(**{ 'value': self.msg_type==SMS_TYPE_IN }) 
7230          self.__field_in_msg.readfrombuffer(buf) 
7231          self.__field_sent_msg=pBOOL(**{ 'value': self.msg_type==SMS_TYPE_SENT }) 
7232          self.__field_sent_msg.readfrombuffer(buf) 
7233          self.__field_draft_msg=pBOOL(**{ 'value': self.msg_type==SMS_TYPE_DRAFT }) 
7234          self.__field_draft_msg.readfrombuffer(buf) 
7235          if self.is_txt_msg.value: 
7236              self.__field_body=sms_body(**{            'msg_len': self.msg_len,            'has_callback': self.bitmap2 & SMS_FLG2_CALLBACK,            'has_priority': self.bitmap2 & SMS_FLG2_PRIORITY,            'has_1byte': self.bitmap2 & SMS_FLG2_SOMETHING,            'has_1byte2': self.bitmap2 & SMS_FLG2_MSG,            'has_40bytes': self.bitmap1 & SMS_FLG1_HAS40 }) 
7237              self.__field_body.readfrombuffer(buf) 
7238          self._bufferendoffset=buf.getcurrentoffset() 
7239   
7240   
7241 -    def __getfield_index(self): 
7242          return self.__field_index.getvalue() 
7243   
7244 -    def __setfield_index(self, value): 
7245          if isinstance(value,UINT): 
7246              self.__field_index=value 
7247          else: 
7248              self.__field_index=UINT(value,**{'sizeinbytes': 2}) 
7249   
7250 -    def __delfield_index(self): del self.__field_index 
7251   
7252      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
7253   
7254 -    def __getfield_msg_len(self): 
7255          return self.__field_msg_len.getvalue() 
7256   
7257 -    def __setfield_msg_len(self, value): 
7258          if isinstance(value,UINT): 
7259              self.__field_msg_len=value 
7260          else: 
7261              self.__field_msg_len=UINT(value,**{'sizeinbytes': 1}) 
7262   
7263 -    def __delfield_msg_len(self): del self.__field_msg_len 
7264   
7265      msg_len=property(__getfield_msg_len, __setfield_msg_len, __delfield_msg_len, None) 
7266   
7267 -    def __getfield_callback_len(self): 
7268          return self.__field_callback_len.getvalue() 
7269   
7270 -    def __setfield_callback_len(self, value): 
7271          if isinstance(value,UINT): 
7272              self.__field_callback_len=value 
7273          else: 
7274              self.__field_callback_len=UINT(value,**{'sizeinbytes': 1}) 
7275   
7276 -    def __delfield_callback_len(self): del self.__field_callback_len 
7277   
7278      callback_len=property(__getfield_callback_len, __setfield_callback_len, __delfield_callback_len, None) 
7279   
7280 -    def __getfield_bitmap1(self): 
7281          return self.__field_bitmap1.getvalue() 
7282   
7283 -    def __setfield_bitmap1(self, value): 
7284          if isinstance(value,UINT): 
7285              self.__field_bitmap1=value 
7286          else: 
7287              self.__field_bitmap1=UINT(value,**{'sizeinbytes': 1}) 
7288   
7289 -    def __delfield_bitmap1(self): del self.__field_bitmap1 
7290   
7291      bitmap1=property(__getfield_bitmap1, __setfield_bitmap1, __delfield_bitmap1, None) 
7292   
7293 -    def __getfield_bitmap2(self): 
7294          return self.__field_bitmap2.getvalue() 
7295   
7296 -    def __setfield_bitmap2(self, value): 
7297          if isinstance(value,UINT): 
7298              self.__field_bitmap2=value 
7299          else: 
7300              self.__field_bitmap2=UINT(value,**{'sizeinbytes': 1}) 
7301   
7302 -    def __delfield_bitmap2(self): del self.__field_bitmap2 
7303   
7304      bitmap2=property(__getfield_bitmap2, __setfield_bitmap2, __delfield_bitmap2, None) 
7305   
7306 -    def __getfield_body_len(self): 
7307          return self.__field_body_len.getvalue() 
7308   
7309 -    def __setfield_body_len(self, value): 
7310          if isinstance(value,UINT): 
7311              self.__field_body_len=value 
7312          else: 
7313              self.__field_body_len=UINT(value,**{'sizeinbytes': 2}) 
7314   
7315 -    def __delfield_body_len(self): del self.__field_body_len 
7316   
7317      body_len=property(__getfield_body_len, __setfield_body_len, __delfield_body_len, None) 
7318   
7319 -    def __getfield_file_type(self): 
7320          return self.__field_file_type.getvalue() 
7321   
7322 -    def __setfield_file_type(self, value): 
7323          if isinstance(value,UINT): 
7324              self.__field_file_type=value 
7325          else: 
7326              self.__field_file_type=UINT(value,**{'sizeinbytes': 2}) 
7327   
7328 -    def __delfield_file_type(self): del self.__field_file_type 
7329   
7330      file_type=property(__getfield_file_type, __setfield_file_type, __delfield_file_type, None) 
7331   
7332 -    def __getfield_msg_type(self): 
7333          return self.__field_msg_type.getvalue() 
7334   
7335 -    def __setfield_msg_type(self, value): 
7336          if isinstance(value,UINT): 
7337              self.__field_msg_type=value 
7338          else: 
7339              self.__field_msg_type=UINT(value,**{'sizeinbytes': 1}) 
7340   
7341 -    def __delfield_msg_type(self): del self.__field_msg_type 
7342   
7343      msg_type=property(__getfield_msg_type, __setfield_msg_type, __delfield_msg_type, None) 
7344   
7345 -    def __getfield_enhance_delivery(self): 
7346          return self.__field_enhance_delivery.getvalue() 
7347   
7348 -    def __setfield_enhance_delivery(self, value): 
7349          if isinstance(value,UINT): 
7350              self.__field_enhance_delivery=value 
7351          else: 
7352              self.__field_enhance_delivery=UINT(value,**{'sizeinbytes': 1}) 
7353   
7354 -    def __delfield_enhance_delivery(self): del self.__field_enhance_delivery 
7355   
7356      enhance_delivery=property(__getfield_enhance_delivery, __setfield_enhance_delivery, __delfield_enhance_delivery, None) 
7357   
7358 -    def __getfield_is_txt_msg(self): 
7359          return self.__field_is_txt_msg.getvalue() 
7360   
7361 -    def __setfield_is_txt_msg(self, value): 
7362          if isinstance(value,pBOOL): 
7363              self.__field_is_txt_msg=value 
7364          else: 
7365              self.__field_is_txt_msg=pBOOL(value,**{ 'value': self.file_type==SMS_TXT_TYPE and self.msg_type in SMS_VALID_TYPE }) 
7366   
7367 -    def __delfield_is_txt_msg(self): del self.__field_is_txt_msg 
7368   
7369      is_txt_msg=property(__getfield_is_txt_msg, __setfield_is_txt_msg, __delfield_is_txt_msg, None) 
7370   
7371 -    def __getfield_in_msg(self): 
7372          return self.__field_in_msg.getvalue() 
7373   
7374 -    def __setfield_in_msg(self, value): 
7375          if isinstance(value,pBOOL): 
7376              self.__field_in_msg=value 
7377          else: 
7378              self.__field_in_msg=pBOOL(value,**{ 'value': self.msg_type==SMS_TYPE_IN }) 
7379   
7380 -    def __delfield_in_msg(self): del self.__field_in_msg 
7381   
7382      in_msg=property(__getfield_in_msg, __setfield_in_msg, __delfield_in_msg, None) 
7383   
7384 -    def __getfield_sent_msg(self): 
7385          return self.__field_sent_msg.getvalue() 
7386   
7387 -    def __setfield_sent_msg(self, value): 
7388          if isinstance(value,pBOOL): 
7389              self.__field_sent_msg=value 
7390          else: 
7391              self.__field_sent_msg=pBOOL(value,**{ 'value': self.msg_type==SMS_TYPE_SENT }) 
7392   
7393 -    def __delfield_sent_msg(self): del self.__field_sent_msg 
7394   
7395      sent_msg=property(__getfield_sent_msg, __setfield_sent_msg, __delfield_sent_msg, None) 
7396   
7397 -    def __getfield_draft_msg(self): 
7398          return self.__field_draft_msg.getvalue() 
7399   
7400 -    def __setfield_draft_msg(self, value): 
7401          if isinstance(value,pBOOL): 
7402              self.__field_draft_msg=value 
7403          else: 
7404              self.__field_draft_msg=pBOOL(value,**{ 'value': self.msg_type==SMS_TYPE_DRAFT }) 
7405   
7406 -    def __delfield_draft_msg(self): del self.__field_draft_msg 
7407   
7408      draft_msg=property(__getfield_draft_msg, __setfield_draft_msg, __delfield_draft_msg, None) 
7409   
7410 -    def __getfield_body(self): 
7411          return self.__field_body.getvalue() 
7412   
7413 -    def __setfield_body(self, value): 
7414          if isinstance(value,sms_body): 
7415              self.__field_body=value 
7416          else: 
7417              self.__field_body=sms_body(value,**{            'msg_len': self.msg_len,            'has_callback': self.bitmap2 & SMS_FLG2_CALLBACK,            'has_priority': self.bitmap2 & SMS_FLG2_PRIORITY,            'has_1byte': self.bitmap2 & SMS_FLG2_SOMETHING,            'has_1byte2': self.bitmap2 & SMS_FLG2_MSG,            'has_40bytes': self.bitmap1 & SMS_FLG1_HAS40 }) 
7418   
7419 -    def __delfield_body(self): del self.__field_body 
7420   
7421      body=property(__getfield_body, __setfield_body, __delfield_body, None) 
7422   
7423 -    def iscontainer(self): 
7424          return True 
7425   
7426 -    def containerelements(self): 
7427          yield ('index', self.__field_index, None) 
7428          yield ('msg_len', self.__field_msg_len, None) 
7429          yield ('callback_len', self.__field_callback_len, None) 
7430          yield ('bitmap1', self.__field_bitmap1, None) 
7431          yield ('bitmap2', self.__field_bitmap2, None) 
7432          yield ('body_len', self.__field_body_len, None) 
7433          yield ('file_type', self.__field_file_type, None) 
7434          yield ('msg_type', self.__field_msg_type, None) 
7435          yield ('enhance_delivery', self.__field_enhance_delivery, None) 
7436          yield ('is_txt_msg', self.__field_is_txt_msg, None) 
7437          yield ('in_msg', self.__field_in_msg, None) 
7438          yield ('sent_msg', self.__field_sent_msg, None) 
7439          yield ('draft_msg', self.__field_draft_msg, None) 
7440          if self.is_txt_msg.value: 
7441              yield ('body', self.__field_body, None) 
7442   
7443   
7444   
7445   
7446 -class sms_msg_stat_list(BaseProtogenClass): 
7447      # Read-From-Buffer-Only Class 
7448      __fields=['status'] 
7449   
7450 -    def __init__(self, *args, **kwargs): 
7451          dict={} 
7452          # What was supplied to this function 
7453          dict.update(kwargs) 
7454          # Parent constructor 
7455          super(sms_msg_stat_list,self).__init__(**dict) 
7456          if self.__class__ is sms_msg_stat_list: 
7457              self._update(args,dict) 
7458   
7459   
7460 -    def getfields(self): 
7461          return self.__fields 
7462   
7463   
7464 -    def _update(self, args, kwargs): 
7465          super(sms_msg_stat_list,self)._update(args,kwargs) 
7466          keys=kwargs.keys() 
7467          for key in keys: 
7468              if key in self.__fields: 
7469                  setattr(self, key, kwargs[key]) 
7470                  del kwargs[key] 
7471          # Were any unrecognized kwargs passed in? 
7472          if __debug__: 
7473              self._complainaboutunusedargs(sms_msg_stat_list,kwargs) 
7474          if len(args): 
7475              dict2={'sizeinbytes': 1} 
7476              dict2.update(kwargs) 
7477              kwargs=dict2 
7478              self.__field_status=UINT(*args,**dict2) 
7479          # Make all P fields that haven't already been constructed 
7480   
7481   
7482 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
7483          'Writes this packet to the supplied buffer' 
7484          raise NotImplementedError 
7485   
7486   
7487 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
7488          'Reads this packet from the supplied buffer' 
7489          self._bufferstartoffset=buf.getcurrentoffset() 
7490          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
7491          self.__field_status=UINT(**{'sizeinbytes': 1}) 
7492          self.__field_status.readfrombuffer(buf) 
7493          self._bufferendoffset=buf.getcurrentoffset() 
7494   
7495   
7496 -    def __getfield_status(self): 
7497          return self.__field_status.getvalue() 
7498   
7499 -    def __setfield_status(self, value): 
7500          if isinstance(value,UINT): 
7501              self.__field_status=value 
7502          else: 
7503              self.__field_status=UINT(value,**{'sizeinbytes': 1}) 
7504   
7505 -    def __delfield_status(self): del self.__field_status 
7506   
7507      status=property(__getfield_status, __setfield_status, __delfield_status, None) 
7508   
7509 -    def iscontainer(self): 
7510          return True 
7511   
7512 -    def containerelements(self): 
7513          yield ('status', self.__field_status, None) 
7514   
7515   
7516   
7517   
7518 -class sms_datetime_list(BaseProtogenClass): 
7519      # Read-From-Buffer-Only Class 
7520      __fields=['datetime'] 
7521   
7522 -    def __init__(self, *args, **kwargs): 
7523          dict={} 
7524          # What was supplied to this function 
7525          dict.update(kwargs) 
7526          # Parent constructor 
7527          super(sms_datetime_list,self).__init__(**dict) 
7528          if self.__class__ is sms_datetime_list: 
7529              self._update(args,dict) 
7530   
7531   
7532 -    def getfields(self): 
7533          return self.__fields 
7534   
7535   
7536 -    def _update(self, args, kwargs): 
7537          super(sms_datetime_list,self)._update(args,kwargs) 
7538          keys=kwargs.keys() 
7539          for key in keys: 
7540              if key in self.__fields: 
7541                  setattr(self, key, kwargs[key]) 
7542                  del kwargs[key] 
7543          # Were any unrecognized kwargs passed in? 
7544          if __debug__: 
7545              self._complainaboutunusedargs(sms_datetime_list,kwargs) 
7546          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
7547          # Make all P fields that haven't already been constructed 
7548   
7549   
7550 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
7551          'Writes this packet to the supplied buffer' 
7552          raise NotImplementedError 
7553   
7554   
7555 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
7556          'Reads this packet from the supplied buffer' 
7557          self._bufferstartoffset=buf.getcurrentoffset() 
7558          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
7559          self.__field_datetime=DateTime1(**{'sizeinbytes': 4}) 
7560          self.__field_datetime.readfrombuffer(buf) 
7561          DONTCARE(**{'sizeinbytes': 4}).readfrombuffer(buf) 
7562          self._bufferendoffset=buf.getcurrentoffset() 
7563   
7564   
7565 -    def __getfield_datetime(self): 
7566          return self.__field_datetime.getvalue() 
7567   
7568 -    def __setfield_datetime(self, value): 
7569          if isinstance(value,DateTime1): 
7570              self.__field_datetime=value 
7571          else: 
7572              self.__field_datetime=DateTime1(value,**{'sizeinbytes': 4}) 
7573   
7574 -    def __delfield_datetime(self): del self.__field_datetime 
7575   
7576      datetime=property(__getfield_datetime, __setfield_datetime, __delfield_datetime, None) 
7577   
7578 -    def iscontainer(self): 
7579          return True 
7580   
7581 -    def containerelements(self): 
7582          yield ('datetime', self.__field_datetime, None) 
7583   
7584   
7585   
7586   
7587 -class sms_delivered_datetime(BaseProtogenClass): 
7588      # Read-From-Buffer-Only Class 
7589      __fields=['datetime'] 
7590   
7591 -    def __init__(self, *args, **kwargs): 
7592          dict={} 
7593          # What was supplied to this function 
7594          dict.update(kwargs) 
7595          # Parent constructor 
7596          super(sms_delivered_datetime,self).__init__(**dict) 
7597          if self.__class__ is sms_delivered_datetime: 
7598              self._update(args,dict) 
7599   
7600   
7601 -    def getfields(self): 
7602          return self.__fields 
7603   
7604   
7605 -    def _update(self, args, kwargs): 
7606          super(sms_delivered_datetime,self)._update(args,kwargs) 
7607          keys=kwargs.keys() 
7608          for key in keys: 
7609              if key in self.__fields: 
7610                  setattr(self, key, kwargs[key]) 
7611                  del kwargs[key] 
7612          # Were any unrecognized kwargs passed in? 
7613          if __debug__: 
7614              self._complainaboutunusedargs(sms_delivered_datetime,kwargs) 
7615          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
7616          # Make all P fields that haven't already been constructed 
7617   
7618   
7619 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
7620          'Writes this packet to the supplied buffer' 
7621          raise NotImplementedError 
7622   
7623   
7624 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
7625          'Reads this packet from the supplied buffer' 
7626          self._bufferstartoffset=buf.getcurrentoffset() 
7627          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
7628          self.__field_datetime=LIST(**{ 'elementclass': sms_datetime_list,             'length': 10 }) 
7629          self.__field_datetime.readfrombuffer(buf) 
7630          DONTCARE(**{'sizeinbytes': 20}).readfrombuffer(buf) 
7631          self._bufferendoffset=buf.getcurrentoffset() 
7632   
7633   
7634 -    def __getfield_datetime(self): 
7635          return self.__field_datetime.getvalue() 
7636   
7637 -    def __setfield_datetime(self, value): 
7638          if isinstance(value,LIST): 
7639              self.__field_datetime=value 
7640          else: 
7641              self.__field_datetime=LIST(value,**{ 'elementclass': sms_datetime_list,             'length': 10 }) 
7642   
7643 -    def __delfield_datetime(self): del self.__field_datetime 
7644   
7645      datetime=property(__getfield_datetime, __setfield_datetime, __delfield_datetime, None) 
7646   
7647 -    def iscontainer(self): 
7648          return True 
7649   
7650 -    def containerelements(self): 
7651          yield ('datetime', self.__field_datetime, None) 
7652   
7653   
7654   
7655   
7656 -class sms_body(BaseProtogenClass): 
7657      # Read-From-Buffer-Only Class 
7658      __fields=['msg_len', 'has_callback', 'has_priority', 'has_1byte', 'has_1byte2', 'has_40bytes', 'msg', 'dunno2', 'callback_len', 'callback', 'priority', 'datetime', 'addr_len0', 'addr_len1', 'addr_len2', 'addr_len3', 'addr_len4', 'addr_len5', 'addr_len6', 'addr_len7', 'addr_len8', 'addr_len9', 'addr0', 'addr1', 'addr2', 'addr3', 'addr4', 'addr5', 'addr6', 'addr7', 'addr8', 'addr9', 'msg_stat'] 
7659   
7660 -    def __init__(self, *args, **kwargs): 
7661          dict={} 
7662          # What was supplied to this function 
7663          dict.update(kwargs) 
7664          # Parent constructor 
7665          super(sms_body,self).__init__(**dict) 
7666          if self.__class__ is sms_body: 
7667              self._update(args,dict) 
7668   
7669   
7670 -    def getfields(self): 
7671          return self.__fields 
7672   
7673   
7674 -    def _update(self, args, kwargs): 
7675          super(sms_body,self)._update(args,kwargs) 
7676          keys=kwargs.keys() 
7677          for key in keys: 
7678              if key in self.__fields: 
7679                  setattr(self, key, kwargs[key]) 
7680                  del kwargs[key] 
7681          # Were any unrecognized kwargs passed in? 
7682          if __debug__: 
7683              self._complainaboutunusedargs(sms_body,kwargs) 
7684          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
7685          # Make all P fields that haven't already been constructed 
7686          try: self.__field_msg_len 
7687          except: 
7688              self.__field_msg_len=UINT() 
7689          try: self.__field_has_callback 
7690          except: 
7691              self.__field_has_callback=BOOL(**{ 'default': True }) 
7692          try: self.__field_has_priority 
7693          except: 
7694              self.__field_has_priority=BOOL(**{ 'default': False }) 
7695          try: self.__field_has_1byte 
7696          except: 
7697              self.__field_has_1byte=BOOL(**{ 'default': False }) 
7698          try: self.__field_has_1byte2 
7699          except: 
7700              self.__field_has_1byte2=BOOL(**{ 'default': True }) 
7701          try: self.__field_has_40bytes 
7702          except: 
7703              self.__field_has_40bytes=BOOL(**{ 'default': False }) 
7704   
7705   
7706 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
7707          'Writes this packet to the supplied buffer' 
7708          raise NotImplementedError 
7709   
7710   
7711 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
7712          'Reads this packet from the supplied buffer' 
7713          self._bufferstartoffset=buf.getcurrentoffset() 
7714          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
7715          DONTCARE(**{'sizeinbytes': 50}).readfrombuffer(buf) 
7716          self.__field_msg=USTRING(**{ 'sizeinbytes': self.msg_len,                'encoding': ENCODING,                'terminator': None }) 
7717          self.__field_msg.readfrombuffer(buf) 
7718          if self.has_callback: 
7719              self.__field_dunno2=UNKNOWN(**{'sizeinbytes': 3}) 
7720              self.__field_dunno2.readfrombuffer(buf) 
7721              self.__field_callback_len=UINT(**{'sizeinbytes': 1}) 
7722              self.__field_callback_len.readfrombuffer(buf) 
7723              self.__field_callback=STRING(**{ 'sizeinbytes': self.callback_len,                   'terminator': None }) 
7724              self.__field_callback.readfrombuffer(buf) 
7725          if self.has_priority: 
7726              self.__field_priority=UINT(**{'sizeinbytes': 1}) 
7727              self.__field_priority.readfrombuffer(buf) 
7728          if self.has_1byte: 
7729              DONTCARE(**{'sizeinbytes': 1}).readfrombuffer(buf) 
7730          DONTCARE(**{'sizeinbytes': 40}).readfrombuffer(buf) 
7731          self.__field_datetime=DateTime1(**{'sizeinbytes': 4}) 
7732          self.__field_datetime.readfrombuffer(buf) 
7733          DONTCARE(**{'sizeinbytes': 17}).readfrombuffer(buf) 
7734          self.__field_addr_len0=UINT(**{'sizeinbytes': 1}) 
7735          self.__field_addr_len0.readfrombuffer(buf) 
7736          self.__field_addr_len1=UINT(**{'sizeinbytes': 1}) 
7737          self.__field_addr_len1.readfrombuffer(buf) 
7738          self.__field_addr_len2=UINT(**{'sizeinbytes': 1}) 
7739          self.__field_addr_len2.readfrombuffer(buf) 
7740          self.__field_addr_len3=UINT(**{'sizeinbytes': 1}) 
7741          self.__field_addr_len3.readfrombuffer(buf) 
7742          self.__field_addr_len4=UINT(**{'sizeinbytes': 1}) 
7743          self.__field_addr_len4.readfrombuffer(buf) 
7744          self.__field_addr_len5=UINT(**{'sizeinbytes': 1}) 
7745          self.__field_addr_len5.readfrombuffer(buf) 
7746          self.__field_addr_len6=UINT(**{'sizeinbytes': 1}) 
7747          self.__field_addr_len6.readfrombuffer(buf) 
7748          self.__field_addr_len7=UINT(**{'sizeinbytes': 1}) 
7749          self.__field_addr_len7.readfrombuffer(buf) 
7750          self.__field_addr_len8=UINT(**{'sizeinbytes': 1}) 
7751          self.__field_addr_len8.readfrombuffer(buf) 
7752          self.__field_addr_len9=UINT(**{'sizeinbytes': 1}) 
7753          self.__field_addr_len9.readfrombuffer(buf) 
7754          if self.addr_len0: 
7755              self.__field_addr0=STRING(**{ 'sizeinbytes': self.addr_len0,                   'terminator': None }) 
7756              self.__field_addr0.readfrombuffer(buf) 
7757          if self.addr_len1: 
7758              self.__field_addr1=STRING(**{ 'sizeinbytes': self.addr_len1,                   'terminator': None }) 
7759              self.__field_addr1.readfrombuffer(buf) 
7760          if self.addr_len2: 
7761              self.__field_addr2=STRING(**{ 'sizeinbytes': self.addr_len2,                   'terminator': None }) 
7762              self.__field_addr2.readfrombuffer(buf) 
7763          if self.addr_len3: 
7764              self.__field_addr3=STRING(**{ 'sizeinbytes': self.addr_len3,                   'terminator': None }) 
7765              self.__field_addr3.readfrombuffer(buf) 
7766          if self.addr_len4: 
7767              self.__field_addr4=STRING(**{ 'sizeinbytes': self.addr_len4,                   'terminator': None }) 
7768              self.__field_addr4.readfrombuffer(buf) 
7769          if self.addr_len5: 
7770              self.__field_addr5=STRING(**{ 'sizeinbytes': self.addr_len5,                   'terminator': None }) 
7771              self.__field_addr5.readfrombuffer(buf) 
7772          if self.addr_len6: 
7773              self.__field_addr6=STRING(**{ 'sizeinbytes': self.addr_len6,                   'terminator': None }) 
7774              self.__field_addr6.readfrombuffer(buf) 
7775          if self.addr_len7: 
7776              self.__field_addr7=STRING(**{ 'sizeinbytes': self.addr_len7,                   'terminator': None }) 
7777              self.__field_addr7.readfrombuffer(buf) 
7778          if self.addr_len8: 
7779              self.__field_addr8=STRING(**{ 'sizeinbytes': self.addr_len8,                   'terminator': None }) 
7780              self.__field_addr8.readfrombuffer(buf) 
7781          if self.addr_len9: 
7782              self.__field_addr9=STRING(**{ 'sizeinbytes': self.addr_len9,                   'terminator': None }) 
7783              self.__field_addr9.readfrombuffer(buf) 
7784          if not self.has_1byte and self.has_1byte2: 
7785              DONTCARE(**{'sizeinbytes': 1}).readfrombuffer(buf) 
7786          if self.has_1byte2: 
7787              DONTCARE(**{'sizeinbytes': 1}).readfrombuffer(buf) 
7788          DONTCARE(**{'sizeinbytes': 21}).readfrombuffer(buf) 
7789          if self.has_40bytes: 
7790              DONTCARE(**{'sizeinbytes': 40}).readfrombuffer(buf) 
7791          self.__field_msg_stat=LIST(**{ 'elementclass': sms_msg_stat_list,             'length': 10 }) 
7792          self.__field_msg_stat.readfrombuffer(buf) 
7793          self._bufferendoffset=buf.getcurrentoffset() 
7794   
7795   
7796 -    def __getfield_msg_len(self): 
7797          return self.__field_msg_len.getvalue() 
7798   
7799 -    def __setfield_msg_len(self, value): 
7800          if isinstance(value,UINT): 
7801              self.__field_msg_len=value 
7802          else: 
7803              self.__field_msg_len=UINT(value,) 
7804   
7805 -    def __delfield_msg_len(self): del self.__field_msg_len 
7806   
7807      msg_len=property(__getfield_msg_len, __setfield_msg_len, __delfield_msg_len, None) 
7808   
7809 -    def __getfield_has_callback(self): 
7810          try: self.__field_has_callback 
7811          except: 
7812              self.__field_has_callback=BOOL(**{ 'default': True }) 
7813          return self.__field_has_callback.getvalue() 
7814   
7815 -    def __setfield_has_callback(self, value): 
7816          if isinstance(value,BOOL): 
7817              self.__field_has_callback=value 
7818          else: 
7819              self.__field_has_callback=BOOL(value,**{ 'default': True }) 
7820   
7821 -    def __delfield_has_callback(self): del self.__field_has_callback 
7822   
7823      has_callback=property(__getfield_has_callback, __setfield_has_callback, __delfield_has_callback, None) 
7824   
7825 -    def __getfield_has_priority(self): 
7826          try: self.__field_has_priority 
7827          except: 
7828              self.__field_has_priority=BOOL(**{ 'default': False }) 
7829          return self.__field_has_priority.getvalue() 
7830   
7831 -    def __setfield_has_priority(self, value): 
7832          if isinstance(value,BOOL): 
7833              self.__field_has_priority=value 
7834          else: 
7835              self.__field_has_priority=BOOL(value,**{ 'default': False }) 
7836   
7837 -    def __delfield_has_priority(self): del self.__field_has_priority 
7838   
7839      has_priority=property(__getfield_has_priority, __setfield_has_priority, __delfield_has_priority, None) 
7840   
7841 -    def __getfield_has_1byte(self): 
7842          try: self.__field_has_1byte 
7843          except: 
7844              self.__field_has_1byte=BOOL(**{ 'default': False }) 
7845          return self.__field_has_1byte.getvalue() 
7846   
7847 -    def __setfield_has_1byte(self, value): 
7848          if isinstance(value,BOOL): 
7849              self.__field_has_1byte=value 
7850          else: 
7851              self.__field_has_1byte=BOOL(value,**{ 'default': False }) 
7852   
7853 -    def __delfield_has_1byte(self): del self.__field_has_1byte 
7854   
7855      has_1byte=property(__getfield_has_1byte, __setfield_has_1byte, __delfield_has_1byte, None) 
7856   
7857 -    def __getfield_has_1byte2(self): 
7858          try: self.__field_has_1byte2 
7859          except: 
7860              self.__field_has_1byte2=BOOL(**{ 'default': True }) 
7861          return self.__field_has_1byte2.getvalue() 
7862   
7863 -    def __setfield_has_1byte2(self, value): 
7864          if isinstance(value,BOOL): 
7865              self.__field_has_1byte2=value 
7866          else: 
7867              self.__field_has_1byte2=BOOL(value,**{ 'default': True }) 
7868   
7869 -    def __delfield_has_1byte2(self): del self.__field_has_1byte2 
7870   
7871      has_1byte2=property(__getfield_has_1byte2, __setfield_has_1byte2, __delfield_has_1byte2, None) 
7872   
7873 -    def __getfield_has_40bytes(self): 
7874          try: self.__field_has_40bytes 
7875          except: 
7876              self.__field_has_40bytes=BOOL(**{ 'default': False }) 
7877          return self.__field_has_40bytes.getvalue() 
7878   
7879 -    def __setfield_has_40bytes(self, value): 
7880          if isinstance(value,BOOL): 
7881              self.__field_has_40bytes=value 
7882          else: 
7883              self.__field_has_40bytes=BOOL(value,**{ 'default': False }) 
7884   
7885 -    def __delfield_has_40bytes(self): del self.__field_has_40bytes 
7886   
7887      has_40bytes=property(__getfield_has_40bytes, __setfield_has_40bytes, __delfield_has_40bytes, None) 
7888   
7889 -    def __getfield_msg(self): 
7890          return self.__field_msg.getvalue() 
7891   
7892 -    def __setfield_msg(self, value): 
7893          if isinstance(value,USTRING): 
7894              self.__field_msg=value 
7895          else: 
7896              self.__field_msg=USTRING(value,**{ 'sizeinbytes': self.msg_len,                'encoding': ENCODING,                'terminator': None }) 
7897   
7898 -    def __delfield_msg(self): del self.__field_msg 
7899   
7900      msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None) 
7901   
7902 -    def __getfield_dunno2(self): 
7903          return self.__field_dunno2.getvalue() 
7904   
7905 -    def __setfield_dunno2(self, value): 
7906          if isinstance(value,UNKNOWN): 
7907              self.__field_dunno2=value 
7908          else: 
7909              self.__field_dunno2=UNKNOWN(value,**{'sizeinbytes': 3}) 
7910   
7911 -    def __delfield_dunno2(self): del self.__field_dunno2 
7912   
7913      dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None) 
7914   
7915 -    def __getfield_callback_len(self): 
7916          return self.__field_callback_len.getvalue() 
7917   
7918 -    def __setfield_callback_len(self, value): 
7919          if isinstance(value,UINT): 
7920              self.__field_callback_len=value 
7921          else: 
7922              self.__field_callback_len=UINT(value,**{'sizeinbytes': 1}) 
7923   
7924 -    def __delfield_callback_len(self): del self.__field_callback_len 
7925   
7926      callback_len=property(__getfield_callback_len, __setfield_callback_len, __delfield_callback_len, None) 
7927   
7928 -    def __getfield_callback(self): 
7929          return self.__field_callback.getvalue() 
7930   
7931 -    def __setfield_callback(self, value): 
7932          if isinstance(value,STRING): 
7933              self.__field_callback=value 
7934          else: 
7935              self.__field_callback=STRING(value,**{ 'sizeinbytes': self.callback_len,                   'terminator': None }) 
7936   
7937 -    def __delfield_callback(self): del self.__field_callback 
7938   
7939      callback=property(__getfield_callback, __setfield_callback, __delfield_callback, None) 
7940   
7941 -    def __getfield_priority(self): 
7942          return self.__field_priority.getvalue() 
7943   
7944 -    def __setfield_priority(self, value): 
7945          if isinstance(value,UINT): 
7946              self.__field_priority=value 
7947          else: 
7948              self.__field_priority=UINT(value,**{'sizeinbytes': 1}) 
7949   
7950 -    def __delfield_priority(self): del self.__field_priority 
7951   
7952      priority=property(__getfield_priority, __setfield_priority, __delfield_priority, None) 
7953   
7954 -    def __getfield_datetime(self): 
7955          return self.__field_datetime.getvalue() 
7956   
7957 -    def __setfield_datetime(self, value): 
7958          if isinstance(value,DateTime1): 
7959              self.__field_datetime=value 
7960          else: 
7961              self.__field_datetime=DateTime1(value,**{'sizeinbytes': 4}) 
7962   
7963 -    def __delfield_datetime(self): del self.__field_datetime 
7964   
7965      datetime=property(__getfield_datetime, __setfield_datetime, __delfield_datetime, None) 
7966   
7967 -    def __getfield_addr_len0(self): 
7968          return self.__field_addr_len0.getvalue() 
7969   
7970 -    def __setfield_addr_len0(self, value): 
7971          if isinstance(value,UINT): 
7972              self.__field_addr_len0=value 
7973          else: 
7974              self.__field_addr_len0=UINT(value,**{'sizeinbytes': 1}) 
7975   
7976 -    def __delfield_addr_len0(self): del self.__field_addr_len0 
7977   
7978      addr_len0=property(__getfield_addr_len0, __setfield_addr_len0, __delfield_addr_len0, None) 
7979   
7980 -    def __getfield_addr_len1(self): 
7981          return self.__field_addr_len1.getvalue() 
7982   
7983 -    def __setfield_addr_len1(self, value): 
7984          if isinstance(value,UINT): 
7985              self.__field_addr_len1=value 
7986          else: 
7987              self.__field_addr_len1=UINT(value,**{'sizeinbytes': 1}) 
7988   
7989 -    def __delfield_addr_len1(self): del self.__field_addr_len1 
7990   
7991      addr_len1=property(__getfield_addr_len1, __setfield_addr_len1, __delfield_addr_len1, None) 
7992   
7993 -    def __getfield_addr_len2(self): 
7994          return self.__field_addr_len2.getvalue() 
7995   
7996 -    def __setfield_addr_len2(self, value): 
7997          if isinstance(value,UINT): 
7998              self.__field_addr_len2=value 
7999          else: 
8000              self.__field_addr_len2=UINT(value,**{'sizeinbytes': 1}) 
8001   
8002 -    def __delfield_addr_len2(self): del self.__field_addr_len2 
8003   
8004      addr_len2=property(__getfield_addr_len2, __setfield_addr_len2, __delfield_addr_len2, None) 
8005   
8006 -    def __getfield_addr_len3(self): 
8007          return self.__field_addr_len3.getvalue() 
8008   
8009 -    def __setfield_addr_len3(self, value): 
8010          if isinstance(value,UINT): 
8011              self.__field_addr_len3=value 
8012          else: 
8013              self.__field_addr_len3=UINT(value,**{'sizeinbytes': 1}) 
8014   
8015 -    def __delfield_addr_len3(self): del self.__field_addr_len3 
8016   
8017      addr_len3=property(__getfield_addr_len3, __setfield_addr_len3, __delfield_addr_len3, None) 
8018   
8019 -    def __getfield_addr_len4(self): 
8020          return self.__field_addr_len4.getvalue() 
8021   
8022 -    def __setfield_addr_len4(self, value): 
8023          if isinstance(value,UINT): 
8024              self.__field_addr_len4=value 
8025          else: 
8026              self.__field_addr_len4=UINT(value,**{'sizeinbytes': 1}) 
8027   
8028 -    def __delfield_addr_len4(self): del self.__field_addr_len4 
8029   
8030      addr_len4=property(__getfield_addr_len4, __setfield_addr_len4, __delfield_addr_len4, None) 
8031   
8032 -    def __getfield_addr_len5(self): 
8033          return self.__field_addr_len5.getvalue() 
8034   
8035 -    def __setfield_addr_len5(self, value): 
8036          if isinstance(value,UINT): 
8037              self.__field_addr_len5=value 
8038          else: 
8039              self.__field_addr_len5=UINT(value,**{'sizeinbytes': 1}) 
8040   
8041 -    def __delfield_addr_len5(self): del self.__field_addr_len5 
8042   
8043      addr_len5=property(__getfield_addr_len5, __setfield_addr_len5, __delfield_addr_len5, None) 
8044   
8045 -    def __getfield_addr_len6(self): 
8046          return self.__field_addr_len6.getvalue() 
8047   
8048 -    def __setfield_addr_len6(self, value): 
8049          if isinstance(value,UINT): 
8050              self.__field_addr_len6=value 
8051          else: 
8052              self.__field_addr_len6=UINT(value,**{'sizeinbytes': 1}) 
8053   
8054 -    def __delfield_addr_len6(self): del self.__field_addr_len6 
8055   
8056      addr_len6=property(__getfield_addr_len6, __setfield_addr_len6, __delfield_addr_len6, None) 
8057   
8058 -    def __getfield_addr_len7(self): 
8059          return self.__field_addr_len7.getvalue() 
8060   
8061 -    def __setfield_addr_len7(self, value): 
8062          if isinstance(value,UINT): 
8063              self.__field_addr_len7=value 
8064          else: 
8065              self.__field_addr_len7=UINT(value,**{'sizeinbytes': 1}) 
8066   
8067 -    def __delfield_addr_len7(self): del self.__field_addr_len7 
8068   
8069      addr_len7=property(__getfield_addr_len7, __setfield_addr_len7, __delfield_addr_len7, None) 
8070   
8071 -    def __getfield_addr_len8(self): 
8072          return self.__field_addr_len8.getvalue() 
8073   
8074 -    def __setfield_addr_len8(self, value): 
8075          if isinstance(value,UINT): 
8076              self.__field_addr_len8=value 
8077          else: 
8078              self.__field_addr_len8=UINT(value,**{'sizeinbytes': 1}) 
8079   
8080 -    def __delfield_addr_len8(self): del self.__field_addr_len8 
8081   
8082      addr_len8=property(__getfield_addr_len8, __setfield_addr_len8, __delfield_addr_len8, None) 
8083   
8084 -    def __getfield_addr_len9(self): 
8085          return self.__field_addr_len9.getvalue() 
8086   
8087 -    def __setfield_addr_len9(self, value): 
8088          if isinstance(value,UINT): 
8089              self.__field_addr_len9=value 
8090          else: 
8091              self.__field_addr_len9=UINT(value,**{'sizeinbytes': 1}) 
8092   
8093 -    def __delfield_addr_len9(self): del self.__field_addr_len9 
8094   
8095      addr_len9=property(__getfield_addr_len9, __setfield_addr_len9, __delfield_addr_len9, None) 
8096   
8097 -    def __getfield_addr0(self): 
8098          return self.__field_addr0.getvalue() 
8099   
8100 -    def __setfield_addr0(self, value): 
8101          if isinstance(value,STRING): 
8102              self.__field_addr0=value 
8103          else: 
8104              self.__field_addr0=STRING(value,**{ 'sizeinbytes': self.addr_len0,                   'terminator': None }) 
8105   
8106 -    def __delfield_addr0(self): del self.__field_addr0 
8107   
8108      addr0=property(__getfield_addr0, __setfield_addr0, __delfield_addr0, None) 
8109   
8110 -    def __getfield_addr1(self): 
8111          return self.__field_addr1.getvalue() 
8112   
8113 -    def __setfield_addr1(self, value): 
8114          if isinstance(value,STRING): 
8115              self.__field_addr1=value 
8116          else: 
8117              self.__field_addr1=STRING(value,**{ 'sizeinbytes': self.addr_len1,                   'terminator': None }) 
8118   
8119 -    def __delfield_addr1(self): del self.__field_addr1 
8120   
8121      addr1=property(__getfield_addr1, __setfield_addr1, __delfield_addr1, None) 
8122   
8123 -    def __getfield_addr2(self): 
8124          return self.__field_addr2.getvalue() 
8125   
8126 -    def __setfield_addr2(self, value): 
8127          if isinstance(value,STRING): 
8128              self.__field_addr2=value 
8129          else: 
8130              self.__field_addr2=STRING(value,**{ 'sizeinbytes': self.addr_len2,                   'terminator': None }) 
8131   
8132 -    def __delfield_addr2(self): del self.__field_addr2 
8133   
8134      addr2=property(__getfield_addr2, __setfield_addr2, __delfield_addr2, None) 
8135   
8136 -    def __getfield_addr3(self): 
8137          return self.__field_addr3.getvalue() 
8138   
8139 -    def __setfield_addr3(self, value): 
8140          if isinstance(value,STRING): 
8141              self.__field_addr3=value 
8142          else: 
8143              self.__field_addr3=STRING(value,**{ 'sizeinbytes': self.addr_len3,                   'terminator': None }) 
8144   
8145 -    def __delfield_addr3(self): del self.__field_addr3 
8146   
8147      addr3=property(__getfield_addr3, __setfield_addr3, __delfield_addr3, None) 
8148   
8149 -    def __getfield_addr4(self): 
8150          return self.__field_addr4.getvalue() 
8151   
8152 -    def __setfield_addr4(self, value): 
8153          if isinstance(value,STRING): 
8154              self.__field_addr4=value 
8155          else: 
8156              self.__field_addr4=STRING(value,**{ 'sizeinbytes': self.addr_len4,                   'terminator': None }) 
8157   
8158 -    def __delfield_addr4(self): del self.__field_addr4 
8159   
8160      addr4=property(__getfield_addr4, __setfield_addr4, __delfield_addr4, None) 
8161   
8162 -    def __getfield_addr5(self): 
8163          return self.__field_addr5.getvalue() 
8164   
8165 -    def __setfield_addr5(self, value): 
8166          if isinstance(value,STRING): 
8167              self.__field_addr5=value 
8168          else: 
8169              self.__field_addr5=STRING(value,**{ 'sizeinbytes': self.addr_len5,                   'terminator': None }) 
8170   
8171 -    def __delfield_addr5(self): del self.__field_addr5 
8172   
8173      addr5=property(__getfield_addr5, __setfield_addr5, __delfield_addr5, None) 
8174   
8175 -    def __getfield_addr6(self): 
8176          return self.__field_addr6.getvalue() 
8177   
8178 -    def __setfield_addr6(self, value): 
8179          if isinstance(value,STRING): 
8180              self.__field_addr6=value 
8181          else: 
8182              self.__field_addr6=STRING(value,**{ 'sizeinbytes': self.addr_len6,                   'terminator': None }) 
8183   
8184 -    def __delfield_addr6(self): del self.__field_addr6 
8185   
8186      addr6=property(__getfield_addr6, __setfield_addr6, __delfield_addr6, None) 
8187   
8188 -    def __getfield_addr7(self): 
8189          return self.__field_addr7.getvalue() 
8190   
8191 -    def __setfield_addr7(self, value): 
8192          if isinstance(value,STRING): 
8193              self.__field_addr7=value 
8194          else: 
8195              self.__field_addr7=STRING(value,**{ 'sizeinbytes': self.addr_len7,                   'terminator': None }) 
8196   
8197 -    def __delfield_addr7(self): del self.__field_addr7 
8198   
8199      addr7=property(__getfield_addr7, __setfield_addr7, __delfield_addr7, None) 
8200   
8201 -    def __getfield_addr8(self): 
8202          return self.__field_addr8.getvalue() 
8203   
8204 -    def __setfield_addr8(self, value): 
8205          if isinstance(value,STRING): 
8206              self.__field_addr8=value 
8207          else: 
8208              self.__field_addr8=STRING(value,**{ 'sizeinbytes': self.addr_len8,                   'terminator': None }) 
8209   
8210 -    def __delfield_addr8(self): del self.__field_addr8 
8211   
8212      addr8=property(__getfield_addr8, __setfield_addr8, __delfield_addr8, None) 
8213   
8214 -    def __getfield_addr9(self): 
8215          return self.__field_addr9.getvalue() 
8216   
8217 -    def __setfield_addr9(self, value): 
8218          if isinstance(value,STRING): 
8219              self.__field_addr9=value 
8220          else: 
8221              self.__field_addr9=STRING(value,**{ 'sizeinbytes': self.addr_len9,                   'terminator': None }) 
8222   
8223 -    def __delfield_addr9(self): del self.__field_addr9 
8224   
8225      addr9=property(__getfield_addr9, __setfield_addr9, __delfield_addr9, None) 
8226   
8227 -    def __getfield_msg_stat(self): 
8228          return self.__field_msg_stat.getvalue() 
8229   
8230 -    def __setfield_msg_stat(self, value): 
8231          if isinstance(value,LIST): 
8232              self.__field_msg_stat=value 
8233          else: 
8234              self.__field_msg_stat=LIST(value,**{ 'elementclass': sms_msg_stat_list,             'length': 10 }) 
8235   
8236 -    def __delfield_msg_stat(self): del self.__field_msg_stat 
8237   
8238      msg_stat=property(__getfield_msg_stat, __setfield_msg_stat, __delfield_msg_stat, None) 
8239   
8240 -    def iscontainer(self): 
8241          return True 
8242   
8243 -    def containerelements(self): 
8244          yield ('msg_len', self.__field_msg_len, None) 
8245          yield ('has_callback', self.__field_has_callback, None) 
8246          yield ('has_priority', self.__field_has_priority, None) 
8247          yield ('has_1byte', self.__field_has_1byte, None) 
8248          yield ('has_1byte2', self.__field_has_1byte2, None) 
8249          yield ('has_40bytes', self.__field_has_40bytes, None) 
8250          yield ('msg', self.__field_msg, None) 
8251          if self.has_callback: 
8252              yield ('dunno2', self.__field_dunno2, None) 
8253              yield ('callback_len', self.__field_callback_len, None) 
8254              yield ('callback', self.__field_callback, None) 
8255          if self.has_priority: 
8256              yield ('priority', self.__field_priority, None) 
8257          if self.has_1byte: 
8258              pass 
8259          yield ('datetime', self.__field_datetime, None) 
8260          yield ('addr_len0', self.__field_addr_len0, None) 
8261          yield ('addr_len1', self.__field_addr_len1, None) 
8262          yield ('addr_len2', self.__field_addr_len2, None) 
8263          yield ('addr_len3', self.__field_addr_len3, None) 
8264          yield ('addr_len4', self.__field_addr_len4, None) 
8265          yield ('addr_len5', self.__field_addr_len5, None) 
8266          yield ('addr_len6', self.__field_addr_len6, None) 
8267          yield ('addr_len7', self.__field_addr_len7, None) 
8268          yield ('addr_len8', self.__field_addr_len8, None) 
8269          yield ('addr_len9', self.__field_addr_len9, None) 
8270          if self.addr_len0: 
8271              yield ('addr0', self.__field_addr0, None) 
8272          if self.addr_len1: 
8273              yield ('addr1', self.__field_addr1, None) 
8274          if self.addr_len2: 
8275              yield ('addr2', self.__field_addr2, None) 
8276          if self.addr_len3: 
8277              yield ('addr3', self.__field_addr3, None) 
8278          if self.addr_len4: 
8279              yield ('addr4', self.__field_addr4, None) 
8280          if self.addr_len5: 
8281              yield ('addr5', self.__field_addr5, None) 
8282          if self.addr_len6: 
8283              yield ('addr6', self.__field_addr6, None) 
8284          if self.addr_len7: 
8285              yield ('addr7', self.__field_addr7, None) 
8286          if self.addr_len8: 
8287              yield ('addr8', self.__field_addr8, None) 
8288          if self.addr_len9: 
8289              yield ('addr9', self.__field_addr9, None) 
8290          if not self.has_1byte and self.has_1byte2: 
8291              pass 
8292          if self.has_1byte2: 
8293              pass 
8294          if self.has_40bytes: 
8295              pass 
8296          yield ('msg_stat', self.__field_msg_stat, None) 
8297