Source Code for Module phones.p_samsungschu750

   1  # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE 
   2   
   3  """Various descriptions of data specific to the Samsung SCH-U750 (Alias 2) Phone""" 
   4   
   5  from prototypes import * 
   6  from prototypes_samsung import * 
   7  from p_brew import * 
   8  from p_samsungschu470 import * 
   9   
  10  SND_PATH='brew/mod/18067' 
  11  SND_INDEX_FILE_NAME=SND_PATH+'/MsInfo.db' 
  12  SND_EXCLUDED_FILES=('MsInfo.db',) 
  13  SND_PRELOADED_PREFIX=SND_PATH+'/SCH-U750_PRELOADED_' 
  14   
  15  # phonebook stuff, 
  16  PB_WP_CACHE_WIDTH=80 
  17  PB_WP_CACHE_HEIGHT=106 
  18  PB_MAX_IMNAME_LEN=50 
  19  PB_MAX_STREET_LEN=50 
  20  PB_MAX_CITY_LEN=50 
  21  PB_MAX_STATE_LEN=50 
  22  PB_MAX_ZIP_LEN=10 
  23  PB_MAX_COUNTRY_LEN=50 
  24  # Flag 
  25  PB_FLG_IMNAME1=0x8000 
  26  # Flag 2 
  27  PB_FLG_IMNAME2=0x0001 
  28  PB_FLG_STREET=0x0002 
  29  PB_FLG_CITY=0x0004 
  30  PB_FLG_STATE=0x0008 
  31  PB_FLG_ZIP=0x0010 
  32  PB_FLG_COUNTRY=0x0020 
  33  PB_FLG_ENTRY_WP=0x0100 
  34  PB_FLG_ENTRY_RT=0x0080 
  35  PB_FLG_ENTRY_CACHED_WP=0x0040 
  36  # each number entry flag 
  37  PB_FLG_DUNNO1=0x04 
  38 -class WSoundsIndexEntry(BaseProtogenClass): 
  39      __fields=['name', 'path_prefix', 'pathname', 'eor'] 
  40   
  41 -    def __init__(self, *args, **kwargs): 
  42          dict={} 
  43          # What was supplied to this function 
  44          dict.update(kwargs) 
  45          # Parent constructor 
  46          super(WSoundsIndexEntry,self).__init__(**dict) 
  47          if self.__class__ is WSoundsIndexEntry: 
  48              self._update(args,dict) 
  49   
  50   
  51 -    def getfields(self): 
  52          return self.__fields 
  53   
  54   
  55 -    def _update(self, args, kwargs): 
  56          super(WSoundsIndexEntry,self)._update(args,kwargs) 
  57          keys=kwargs.keys() 
  58          for key in keys: 
  59              if key in self.__fields: 
  60                  setattr(self, key, kwargs[key]) 
  61                  del kwargs[key] 
  62          # Were any unrecognized kwargs passed in? 
  63          if __debug__: 
  64              self._complainaboutunusedargs(WSoundsIndexEntry,kwargs) 
  65          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
  66          # Make all P fields that haven't already been constructed 
  67          try: self.__field_name 
  68          except: 
  69              self.__field_name=STRING() 
  70   
  71   
  72 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
  73          'Writes this packet to the supplied buffer' 
  74          self._bufferstartoffset=buf.getcurrentoffset() 
  75          try: self.__field_path_prefix 
  76          except: 
  77              self.__field_path_prefix=STRING(**{ 'terminator': None,               'default': '/ff/' }) 
  78          self.__field_path_prefix.writetobuffer(buf) 
  79          self.__field_pathname.writetobuffer(buf) 
  80          try: self.__field_eor 
  81          except: 
  82              self.__field_eor=STRING(**{ 'terminator': None,               'default': '|0|7\x0A' }) 
  83          self.__field_eor.writetobuffer(buf) 
  84          self._bufferendoffset=buf.getcurrentoffset() 
  85          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
  86   
  87   
  88 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
  89          'Reads this packet from the supplied buffer' 
  90          self._bufferstartoffset=buf.getcurrentoffset() 
  91          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
  92          self.__field_path_prefix=STRING(**{ 'terminator': None,               'default': '/ff/' }) 
  93          self.__field_path_prefix.readfrombuffer(buf) 
  94          self.__field_pathname=STRING(**{ 'terminator': None }) 
  95          self.__field_pathname.readfrombuffer(buf) 
  96          self.__field_eor=STRING(**{ 'terminator': None,               'default': '|0|7\x0A' }) 
  97          self.__field_eor.readfrombuffer(buf) 
  98          self._bufferendoffset=buf.getcurrentoffset() 
  99   
 100   
 101 -    def __getfield_name(self): 
 102          return self.__field_name.getvalue() 
 103   
 104 -    def __setfield_name(self, value): 
 105          if isinstance(value,STRING): 
 106              self.__field_name=value 
 107          else: 
 108              self.__field_name=STRING(value,) 
 109   
 110 -    def __delfield_name(self): del self.__field_name 
 111   
 112      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
 113   
 114 -    def __getfield_path_prefix(self): 
 115          try: self.__field_path_prefix 
 116          except: 
 117              self.__field_path_prefix=STRING(**{ 'terminator': None,               'default': '/ff/' }) 
 118          return self.__field_path_prefix.getvalue() 
 119   
 120 -    def __setfield_path_prefix(self, value): 
 121          if isinstance(value,STRING): 
 122              self.__field_path_prefix=value 
 123          else: 
 124              self.__field_path_prefix=STRING(value,**{ 'terminator': None,               'default': '/ff/' }) 
 125   
 126 -    def __delfield_path_prefix(self): del self.__field_path_prefix 
 127   
 128      path_prefix=property(__getfield_path_prefix, __setfield_path_prefix, __delfield_path_prefix, None) 
 129   
 130 -    def __getfield_pathname(self): 
 131          return self.__field_pathname.getvalue() 
 132   
 133 -    def __setfield_pathname(self, value): 
 134          if isinstance(value,STRING): 
 135              self.__field_pathname=value 
 136          else: 
 137              self.__field_pathname=STRING(value,**{ 'terminator': None }) 
 138   
 139 -    def __delfield_pathname(self): del self.__field_pathname 
 140   
 141      pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None) 
 142   
 143 -    def __getfield_eor(self): 
 144          try: self.__field_eor 
 145          except: 
 146              self.__field_eor=STRING(**{ 'terminator': None,               'default': '|0|7\x0A' }) 
 147          return self.__field_eor.getvalue() 
 148   
 149 -    def __setfield_eor(self, value): 
 150          if isinstance(value,STRING): 
 151              self.__field_eor=value 
 152          else: 
 153              self.__field_eor=STRING(value,**{ 'terminator': None,               'default': '|0|7\x0A' }) 
 154   
 155 -    def __delfield_eor(self): del self.__field_eor 
 156   
 157      eor=property(__getfield_eor, __setfield_eor, __delfield_eor, None) 
 158   
 159 -    def iscontainer(self): 
 160          return True 
 161   
 162 -    def containerelements(self): 
 163          yield ('name', self.__field_name, None) 
 164          yield ('path_prefix', self.__field_path_prefix, None) 
 165          yield ('pathname', self.__field_pathname, None) 
 166          yield ('eor', self.__field_eor, None) 
 167   
 168   
 169   
 170   
 171 -class WSoundsIndexFile(BaseProtogenClass): 
 172      __fields=['items'] 
 173   
 174 -    def __init__(self, *args, **kwargs): 
 175          dict={} 
 176          # What was supplied to this function 
 177          dict.update(kwargs) 
 178          # Parent constructor 
 179          super(WSoundsIndexFile,self).__init__(**dict) 
 180          if self.__class__ is WSoundsIndexFile: 
 181              self._update(args,dict) 
 182   
 183   
 184 -    def getfields(self): 
 185          return self.__fields 
 186   
 187   
 188 -    def _update(self, args, kwargs): 
 189          super(WSoundsIndexFile,self)._update(args,kwargs) 
 190          keys=kwargs.keys() 
 191          for key in keys: 
 192              if key in self.__fields: 
 193                  setattr(self, key, kwargs[key]) 
 194                  del kwargs[key] 
 195          # Were any unrecognized kwargs passed in? 
 196          if __debug__: 
 197              self._complainaboutunusedargs(WSoundsIndexFile,kwargs) 
 198          if len(args): 
 199              dict2={ 'elementclass': WSoundsIndexEntry } 
 200              dict2.update(kwargs) 
 201              kwargs=dict2 
 202              self.__field_items=LIST(*args,**dict2) 
 203          # Make all P fields that haven't already been constructed 
 204   
 205   
 206 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 207          'Writes this packet to the supplied buffer' 
 208          self._bufferstartoffset=buf.getcurrentoffset() 
 209          try: self.__field_items 
 210          except: 
 211              self.__field_items=LIST(**{ 'elementclass': WSoundsIndexEntry }) 
 212          self.__field_items.writetobuffer(buf) 
 213          self._bufferendoffset=buf.getcurrentoffset() 
 214          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 215   
 216   
 217 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 218          'Reads this packet from the supplied buffer' 
 219          self._bufferstartoffset=buf.getcurrentoffset() 
 220          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 221          self.__field_items=LIST(**{ 'elementclass': WSoundsIndexEntry }) 
 222          self.__field_items.readfrombuffer(buf) 
 223          self._bufferendoffset=buf.getcurrentoffset() 
 224   
 225   
 226 -    def __getfield_items(self): 
 227          try: self.__field_items 
 228          except: 
 229              self.__field_items=LIST(**{ 'elementclass': WSoundsIndexEntry }) 
 230          return self.__field_items.getvalue() 
 231   
 232 -    def __setfield_items(self, value): 
 233          if isinstance(value,LIST): 
 234              self.__field_items=value 
 235          else: 
 236              self.__field_items=LIST(value,**{ 'elementclass': WSoundsIndexEntry }) 
 237   
 238 -    def __delfield_items(self): del self.__field_items 
 239   
 240      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
 241   
 242 -    def iscontainer(self): 
 243          return True 
 244   
 245 -    def containerelements(self): 
 246          yield ('items', self.__field_items, None) 
 247   
 248   
 249   
 250   
 251 -class RSoundIndexEntry(BaseProtogenClass): 
 252      __fields=['pathname', 'misc'] 
 253   
 254 -    def __init__(self, *args, **kwargs): 
 255          dict={} 
 256          # What was supplied to this function 
 257          dict.update(kwargs) 
 258          # Parent constructor 
 259          super(RSoundIndexEntry,self).__init__(**dict) 
 260          if self.__class__ is RSoundIndexEntry: 
 261              self._update(args,dict) 
 262   
 263   
 264 -    def getfields(self): 
 265          return self.__fields 
 266   
 267   
 268 -    def _update(self, args, kwargs): 
 269          super(RSoundIndexEntry,self)._update(args,kwargs) 
 270          keys=kwargs.keys() 
 271          for key in keys: 
 272              if key in self.__fields: 
 273                  setattr(self, key, kwargs[key]) 
 274                  del kwargs[key] 
 275          # Were any unrecognized kwargs passed in? 
 276          if __debug__: 
 277              self._complainaboutunusedargs(RSoundIndexEntry,kwargs) 
 278          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 279          # Make all P fields that haven't already been constructed 
 280   
 281   
 282 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 283          'Writes this packet to the supplied buffer' 
 284          self._bufferstartoffset=buf.getcurrentoffset() 
 285          self.__field_pathname.writetobuffer(buf) 
 286          self.__field_misc.writetobuffer(buf) 
 287          self._bufferendoffset=buf.getcurrentoffset() 
 288          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 289   
 290   
 291 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 292          'Reads this packet from the supplied buffer' 
 293          self._bufferstartoffset=buf.getcurrentoffset() 
 294          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 295          self.__field_pathname=STRING(**{ 'terminator': 0x7C }) 
 296          self.__field_pathname.readfrombuffer(buf) 
 297          self.__field_misc=STRING(**{ 'terminator': 0x0A }) 
 298          self.__field_misc.readfrombuffer(buf) 
 299          self._bufferendoffset=buf.getcurrentoffset() 
 300   
 301   
 302 -    def __getfield_pathname(self): 
 303          return self.__field_pathname.getvalue() 
 304   
 305 -    def __setfield_pathname(self, value): 
 306          if isinstance(value,STRING): 
 307              self.__field_pathname=value 
 308          else: 
 309              self.__field_pathname=STRING(value,**{ 'terminator': 0x7C }) 
 310   
 311 -    def __delfield_pathname(self): del self.__field_pathname 
 312   
 313      pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None) 
 314   
 315 -    def __getfield_misc(self): 
 316          return self.__field_misc.getvalue() 
 317   
 318 -    def __setfield_misc(self, value): 
 319          if isinstance(value,STRING): 
 320              self.__field_misc=value 
 321          else: 
 322              self.__field_misc=STRING(value,**{ 'terminator': 0x0A }) 
 323   
 324 -    def __delfield_misc(self): del self.__field_misc 
 325   
 326      misc=property(__getfield_misc, __setfield_misc, __delfield_misc, None) 
 327   
 328 -    def iscontainer(self): 
 329          return True 
 330   
 331 -    def containerelements(self): 
 332          yield ('pathname', self.__field_pathname, None) 
 333          yield ('misc', self.__field_misc, None) 
 334   
 335   
 336   
 337   
 338 -class RSoundsIndexFile(BaseProtogenClass): 
 339      __fields=['items'] 
 340   
 341 -    def __init__(self, *args, **kwargs): 
 342          dict={} 
 343          # What was supplied to this function 
 344          dict.update(kwargs) 
 345          # Parent constructor 
 346          super(RSoundsIndexFile,self).__init__(**dict) 
 347          if self.__class__ is RSoundsIndexFile: 
 348              self._update(args,dict) 
 349   
 350   
 351 -    def getfields(self): 
 352          return self.__fields 
 353   
 354   
 355 -    def _update(self, args, kwargs): 
 356          super(RSoundsIndexFile,self)._update(args,kwargs) 
 357          keys=kwargs.keys() 
 358          for key in keys: 
 359              if key in self.__fields: 
 360                  setattr(self, key, kwargs[key]) 
 361                  del kwargs[key] 
 362          # Were any unrecognized kwargs passed in? 
 363          if __debug__: 
 364              self._complainaboutunusedargs(RSoundsIndexFile,kwargs) 
 365          if len(args): 
 366              dict2={ 'elementclass': RSoundIndexEntry } 
 367              dict2.update(kwargs) 
 368              kwargs=dict2 
 369              self.__field_items=LIST(*args,**dict2) 
 370          # Make all P fields that haven't already been constructed 
 371   
 372   
 373 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 374          'Writes this packet to the supplied buffer' 
 375          self._bufferstartoffset=buf.getcurrentoffset() 
 376          try: self.__field_items 
 377          except: 
 378              self.__field_items=LIST(**{ 'elementclass': RSoundIndexEntry }) 
 379          self.__field_items.writetobuffer(buf) 
 380          self._bufferendoffset=buf.getcurrentoffset() 
 381          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 382   
 383   
 384 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 385          'Reads this packet from the supplied buffer' 
 386          self._bufferstartoffset=buf.getcurrentoffset() 
 387          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 388          self.__field_items=LIST(**{ 'elementclass': RSoundIndexEntry }) 
 389          self.__field_items.readfrombuffer(buf) 
 390          self._bufferendoffset=buf.getcurrentoffset() 
 391   
 392   
 393 -    def __getfield_items(self): 
 394          try: self.__field_items 
 395          except: 
 396              self.__field_items=LIST(**{ 'elementclass': RSoundIndexEntry }) 
 397          return self.__field_items.getvalue() 
 398   
 399 -    def __setfield_items(self, value): 
 400          if isinstance(value,LIST): 
 401              self.__field_items=value 
 402          else: 
 403              self.__field_items=LIST(value,**{ 'elementclass': RSoundIndexEntry }) 
 404   
 405 -    def __delfield_items(self): del self.__field_items 
 406   
 407      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
 408   
 409 -    def iscontainer(self): 
 410          return True 
 411   
 412 -    def containerelements(self): 
 413          yield ('items', self.__field_items, None) 
 414   
 415   
 416   
 417   
 418 -class NumberEntry(BaseProtogenClass): 
 419      # Read-From-Buffer-Only Class 
 420      __fields=['number', 'option', 'speeddial'] 
 421   
 422 -    def __init__(self, *args, **kwargs): 
 423          dict={} 
 424          # What was supplied to this function 
 425          dict.update(kwargs) 
 426          # Parent constructor 
 427          super(NumberEntry,self).__init__(**dict) 
 428          if self.__class__ is NumberEntry: 
 429              self._update(args,dict) 
 430   
 431   
 432 -    def getfields(self): 
 433          return self.__fields 
 434   
 435   
 436 -    def _update(self, args, kwargs): 
 437          super(NumberEntry,self)._update(args,kwargs) 
 438          keys=kwargs.keys() 
 439          for key in keys: 
 440              if key in self.__fields: 
 441                  setattr(self, key, kwargs[key]) 
 442                  del kwargs[key] 
 443          # Were any unrecognized kwargs passed in? 
 444          if __debug__: 
 445              self._complainaboutunusedargs(NumberEntry,kwargs) 
 446          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 447          # Make all P fields that haven't already been constructed 
 448   
 449   
 450 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 451          'Writes this packet to the supplied buffer' 
 452          raise NotImplementedError 
 453   
 454   
 455 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 456          'Reads this packet from the supplied buffer' 
 457          self._bufferstartoffset=buf.getcurrentoffset() 
 458          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 459          self.__field_number=STRING(**{ 'terminator': None,               'pascal': True }) 
 460          self.__field_number.readfrombuffer(buf) 
 461          self.__field_option=UINT(**{'sizeinbytes': 1}) 
 462          self.__field_option.readfrombuffer(buf) 
 463          if self.has_speeddial: 
 464              self.__field_speeddial=UINT(**{'sizeinbytes': 2}) 
 465              self.__field_speeddial.readfrombuffer(buf) 
 466          if self.has_dunno1: 
 467              DONTCARE(**{'sizeinbytes': 4}).readfrombuffer(buf) 
 468          self._bufferendoffset=buf.getcurrentoffset() 
 469   
 470   
 471 -    def __getfield_number(self): 
 472          return self.__field_number.getvalue() 
 473   
 474 -    def __setfield_number(self, value): 
 475          if isinstance(value,STRING): 
 476              self.__field_number=value 
 477          else: 
 478              self.__field_number=STRING(value,**{ 'terminator': None,               'pascal': True }) 
 479   
 480 -    def __delfield_number(self): del self.__field_number 
 481   
 482      number=property(__getfield_number, __setfield_number, __delfield_number, None) 
 483   
 484 -    def __getfield_option(self): 
 485          return self.__field_option.getvalue() 
 486   
 487 -    def __setfield_option(self, value): 
 488          if isinstance(value,UINT): 
 489              self.__field_option=value 
 490          else: 
 491              self.__field_option=UINT(value,**{'sizeinbytes': 1}) 
 492   
 493 -    def __delfield_option(self): del self.__field_option 
 494   
 495      option=property(__getfield_option, __setfield_option, __delfield_option, None) 
 496   
 497 -    def __getfield_speeddial(self): 
 498          return self.__field_speeddial.getvalue() 
 499   
 500 -    def __setfield_speeddial(self, value): 
 501          if isinstance(value,UINT): 
 502              self.__field_speeddial=value 
 503          else: 
 504              self.__field_speeddial=UINT(value,**{'sizeinbytes': 2}) 
 505   
 506 -    def __delfield_speeddial(self): del self.__field_speeddial 
 507   
 508      speeddial=property(__getfield_speeddial, __setfield_speeddial, __delfield_speeddial, None) 
 509   
 510 -    def iscontainer(self): 
 511          return True 
 512   
 513 -    def containerelements(self): 
 514          yield ('number', self.__field_number, None) 
 515          yield ('option', self.__field_option, None) 
 516          if self.has_speeddial: 
 517              yield ('speeddial', self.__field_speeddial, None) 
 518          if self.has_dunno1: 
 519              pass 
 520   
 521      @property 
 522 -    def has_speeddial(self): 
 523          return bool(self.option & PB_FLG_SPEEDDIAL) 
 524      @property 
 525 -    def has_dunno1(self): 
 526          return bool(self.option & PB_FLG_DUNNO1) 
 527      @property 
 528 -    def is_primary(self): 
 529          return bool(self.option & PB_FLG_PRIMARY) 
 530      @property 
 531 -    def has_ringtone(self): 
 532          return False 
 533   
 534   
 535   
 536   
 537 -class PBEntry(BaseProtogenClass): 
 538      # Read-From-Buffer-Only Class 
 539      __fields=['info', 'info2', 'name', 'email', 'email2', 'home', 'work', 'cell', 'fax', 'cell2', 'note', 'datetime', 'group', 'im_name', 'im_type', 'street', 'city', 'state', 'zipcode', 'country', 'cached_wp', 'cached_wp_num', 'ringtone', 'wallpaper'] 
 540   
 541 -    def __init__(self, *args, **kwargs): 
 542          dict={} 
 543          # What was supplied to this function 
 544          dict.update(kwargs) 
 545          # Parent constructor 
 546          super(PBEntry,self).__init__(**dict) 
 547          if self.__class__ is PBEntry: 
 548              self._update(args,dict) 
 549   
 550   
 551 -    def getfields(self): 
 552          return self.__fields 
 553   
 554   
 555 -    def _update(self, args, kwargs): 
 556          super(PBEntry,self)._update(args,kwargs) 
 557          keys=kwargs.keys() 
 558          for key in keys: 
 559              if key in self.__fields: 
 560                  setattr(self, key, kwargs[key]) 
 561                  del kwargs[key] 
 562          # Were any unrecognized kwargs passed in? 
 563          if __debug__: 
 564              self._complainaboutunusedargs(PBEntry,kwargs) 
 565          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 566          # Make all P fields that haven't already been constructed 
 567   
 568   
 569 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 570          'Writes this packet to the supplied buffer' 
 571          raise NotImplementedError 
 572   
 573   
 574 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 575          'Reads this packet from the supplied buffer' 
 576          self._bufferstartoffset=buf.getcurrentoffset() 
 577          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 578          self.__field_info=UINT(**{'sizeinbytes': 2}) 
 579          self.__field_info.readfrombuffer(buf) 
 580          self.__field_info2=UINT(**{'sizeinbytes': 2}) 
 581          self.__field_info2.readfrombuffer(buf) 
 582          if self.has_name: 
 583              self.__field_name=USTRING(**{ 'terminator': None,                    'encoding': ENCODING,                    'pascal': True }) 
 584              self.__field_name.readfrombuffer(buf) 
 585          if self.has_email: 
 586              self.__field_email=USTRING(**{ 'terminator': None,                    'encoding': ENCODING,                    'pascal': True }) 
 587              self.__field_email.readfrombuffer(buf) 
 588          if self.has_email2: 
 589              self.__field_email2=USTRING(**{ 'terminator': None,                    'encoding': ENCODING,                   'pascal': True }) 
 590              self.__field_email2.readfrombuffer(buf) 
 591          if self.has_home: 
 592              self.__field_home=NumberEntry() 
 593              self.__field_home.readfrombuffer(buf) 
 594          if self.has_work: 
 595              self.__field_work=NumberEntry() 
 596              self.__field_work.readfrombuffer(buf) 
 597          if self.has_cell: 
 598              self.__field_cell=NumberEntry() 
 599              self.__field_cell.readfrombuffer(buf) 
 600          if self.has_fax: 
 601              self.__field_fax=NumberEntry() 
 602              self.__field_fax.readfrombuffer(buf) 
 603          if self.has_cell2: 
 604              self.__field_cell2=NumberEntry() 
 605              self.__field_cell2.readfrombuffer(buf) 
 606          if self.has_note: 
 607              self.__field_note=STRING(**{ 'terminator': None,                   'pascal': True }) 
 608              self.__field_note.readfrombuffer(buf) 
 609          if self.has_date: 
 610              self.__field_datetime=DateTime(**{'sizeinbytes': 4}) 
 611              self.__field_datetime.readfrombuffer(buf) 
 612          if self.has_group: 
 613              self.__field_group=UINT(**{'sizeinbytes': 4}) 
 614              self.__field_group.readfrombuffer(buf) 
 615          if self.has_im_name: 
 616              self.__field_im_name=STRING(**{ 'terminator': None,                   'pascal': True }) 
 617              self.__field_im_name.readfrombuffer(buf) 
 618              self.__field_im_type=UINT(**{'sizeinbytes': 1}) 
 619              self.__field_im_type.readfrombuffer(buf) 
 620          if self.has_street: 
 621              self.__field_street=STRING(**{ 'terminator': None,                   'pascal': True }) 
 622              self.__field_street.readfrombuffer(buf) 
 623          if self.has_city: 
 624              self.__field_city=STRING(**{ 'terminator': None,                   'pascal': True }) 
 625              self.__field_city.readfrombuffer(buf) 
 626          if self.has_state: 
 627              self.__field_state=STRING(**{ 'terminator': None,                   'pascal': True }) 
 628              self.__field_state.readfrombuffer(buf) 
 629          if self.has_zipcode: 
 630              self.__field_zipcode=STRING(**{ 'terminator': None,                   'pascal': True }) 
 631              self.__field_zipcode.readfrombuffer(buf) 
 632          if self.has_country: 
 633              self.__field_country=STRING(**{ 'terminator': None,                   'pascal': True }) 
 634              self.__field_country.readfrombuffer(buf) 
 635          if self.has_cached_wp: 
 636              self.__field_cached_wp=STRING(**{ 'terminator': None,                   'pascal': True }) 
 637              self.__field_cached_wp.readfrombuffer(buf) 
 638              self.__field_cached_wp_num=UINT(**{'sizeinbytes': 4}) 
 639              self.__field_cached_wp_num.readfrombuffer(buf) 
 640          if self.has_ringtone: 
 641              self.__field_ringtone=STRING(**{ 'terminator': None,                   'pascal': True }) 
 642              self.__field_ringtone.readfrombuffer(buf) 
 643          if self.has_wallpaper: 
 644              self.__field_wallpaper=STRING(**{ 'terminator': None,                   'pascal': True }) 
 645              self.__field_wallpaper.readfrombuffer(buf) 
 646          self._bufferendoffset=buf.getcurrentoffset() 
 647   
 648   
 649 -    def __getfield_info(self): 
 650          return self.__field_info.getvalue() 
 651   
 652 -    def __setfield_info(self, value): 
 653          if isinstance(value,UINT): 
 654              self.__field_info=value 
 655          else: 
 656              self.__field_info=UINT(value,**{'sizeinbytes': 2}) 
 657   
 658 -    def __delfield_info(self): del self.__field_info 
 659   
 660      info=property(__getfield_info, __setfield_info, __delfield_info, None) 
 661   
 662 -    def __getfield_info2(self): 
 663          return self.__field_info2.getvalue() 
 664   
 665 -    def __setfield_info2(self, value): 
 666          if isinstance(value,UINT): 
 667              self.__field_info2=value 
 668          else: 
 669              self.__field_info2=UINT(value,**{'sizeinbytes': 2}) 
 670   
 671 -    def __delfield_info2(self): del self.__field_info2 
 672   
 673      info2=property(__getfield_info2, __setfield_info2, __delfield_info2, None) 
 674   
 675 -    def __getfield_name(self): 
 676          return self.__field_name.getvalue() 
 677   
 678 -    def __setfield_name(self, value): 
 679          if isinstance(value,USTRING): 
 680              self.__field_name=value 
 681          else: 
 682              self.__field_name=USTRING(value,**{ 'terminator': None,                    'encoding': ENCODING,                    'pascal': True }) 
 683   
 684 -    def __delfield_name(self): del self.__field_name 
 685   
 686      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
 687   
 688 -    def __getfield_email(self): 
 689          return self.__field_email.getvalue() 
 690   
 691 -    def __setfield_email(self, value): 
 692          if isinstance(value,USTRING): 
 693              self.__field_email=value 
 694          else: 
 695              self.__field_email=USTRING(value,**{ 'terminator': None,                    'encoding': ENCODING,                    'pascal': True }) 
 696   
 697 -    def __delfield_email(self): del self.__field_email 
 698   
 699      email=property(__getfield_email, __setfield_email, __delfield_email, None) 
 700   
 701 -    def __getfield_email2(self): 
 702          return self.__field_email2.getvalue() 
 703   
 704 -    def __setfield_email2(self, value): 
 705          if isinstance(value,USTRING): 
 706              self.__field_email2=value 
 707          else: 
 708              self.__field_email2=USTRING(value,**{ 'terminator': None,                    'encoding': ENCODING,                   'pascal': True }) 
 709   
 710 -    def __delfield_email2(self): del self.__field_email2 
 711   
 712      email2=property(__getfield_email2, __setfield_email2, __delfield_email2, None) 
 713   
 714 -    def __getfield_home(self): 
 715          return self.__field_home.getvalue() 
 716   
 717 -    def __setfield_home(self, value): 
 718          if isinstance(value,NumberEntry): 
 719              self.__field_home=value 
 720          else: 
 721              self.__field_home=NumberEntry(value,) 
 722   
 723 -    def __delfield_home(self): del self.__field_home 
 724   
 725      home=property(__getfield_home, __setfield_home, __delfield_home, None) 
 726   
 727 -    def __getfield_work(self): 
 728          return self.__field_work.getvalue() 
 729   
 730 -    def __setfield_work(self, value): 
 731          if isinstance(value,NumberEntry): 
 732              self.__field_work=value 
 733          else: 
 734              self.__field_work=NumberEntry(value,) 
 735   
 736 -    def __delfield_work(self): del self.__field_work 
 737   
 738      work=property(__getfield_work, __setfield_work, __delfield_work, None) 
 739   
 740 -    def __getfield_cell(self): 
 741          return self.__field_cell.getvalue() 
 742   
 743 -    def __setfield_cell(self, value): 
 744          if isinstance(value,NumberEntry): 
 745              self.__field_cell=value 
 746          else: 
 747              self.__field_cell=NumberEntry(value,) 
 748   
 749 -    def __delfield_cell(self): del self.__field_cell 
 750   
 751      cell=property(__getfield_cell, __setfield_cell, __delfield_cell, None) 
 752   
 753 -    def __getfield_fax(self): 
 754          return self.__field_fax.getvalue() 
 755   
 756 -    def __setfield_fax(self, value): 
 757          if isinstance(value,NumberEntry): 
 758              self.__field_fax=value 
 759          else: 
 760              self.__field_fax=NumberEntry(value,) 
 761   
 762 -    def __delfield_fax(self): del self.__field_fax 
 763   
 764      fax=property(__getfield_fax, __setfield_fax, __delfield_fax, None) 
 765   
 766 -    def __getfield_cell2(self): 
 767          return self.__field_cell2.getvalue() 
 768   
 769 -    def __setfield_cell2(self, value): 
 770          if isinstance(value,NumberEntry): 
 771              self.__field_cell2=value 
 772          else: 
 773              self.__field_cell2=NumberEntry(value,) 
 774   
 775 -    def __delfield_cell2(self): del self.__field_cell2 
 776   
 777      cell2=property(__getfield_cell2, __setfield_cell2, __delfield_cell2, None) 
 778   
 779 -    def __getfield_note(self): 
 780          return self.__field_note.getvalue() 
 781   
 782 -    def __setfield_note(self, value): 
 783          if isinstance(value,STRING): 
 784              self.__field_note=value 
 785          else: 
 786              self.__field_note=STRING(value,**{ 'terminator': None,                   'pascal': True }) 
 787   
 788 -    def __delfield_note(self): del self.__field_note 
 789   
 790      note=property(__getfield_note, __setfield_note, __delfield_note, None) 
 791   
 792 -    def __getfield_datetime(self): 
 793          return self.__field_datetime.getvalue() 
 794   
 795 -    def __setfield_datetime(self, value): 
 796          if isinstance(value,DateTime): 
 797              self.__field_datetime=value 
 798          else: 
 799              self.__field_datetime=DateTime(value,**{'sizeinbytes': 4}) 
 800   
 801 -    def __delfield_datetime(self): del self.__field_datetime 
 802   
 803      datetime=property(__getfield_datetime, __setfield_datetime, __delfield_datetime, None) 
 804   
 805 -    def __getfield_group(self): 
 806          return self.__field_group.getvalue() 
 807   
 808 -    def __setfield_group(self, value): 
 809          if isinstance(value,UINT): 
 810              self.__field_group=value 
 811          else: 
 812              self.__field_group=UINT(value,**{'sizeinbytes': 4}) 
 813   
 814 -    def __delfield_group(self): del self.__field_group 
 815   
 816      group=property(__getfield_group, __setfield_group, __delfield_group, None) 
 817   
 818 -    def __getfield_im_name(self): 
 819          return self.__field_im_name.getvalue() 
 820   
 821 -    def __setfield_im_name(self, value): 
 822          if isinstance(value,STRING): 
 823              self.__field_im_name=value 
 824          else: 
 825              self.__field_im_name=STRING(value,**{ 'terminator': None,                   'pascal': True }) 
 826   
 827 -    def __delfield_im_name(self): del self.__field_im_name 
 828   
 829      im_name=property(__getfield_im_name, __setfield_im_name, __delfield_im_name, None) 
 830   
 831 -    def __getfield_im_type(self): 
 832          return self.__field_im_type.getvalue() 
 833   
 834 -    def __setfield_im_type(self, value): 
 835          if isinstance(value,UINT): 
 836              self.__field_im_type=value 
 837          else: 
 838              self.__field_im_type=UINT(value,**{'sizeinbytes': 1}) 
 839   
 840 -    def __delfield_im_type(self): del self.__field_im_type 
 841   
 842      im_type=property(__getfield_im_type, __setfield_im_type, __delfield_im_type, None) 
 843   
 844 -    def __getfield_street(self): 
 845          return self.__field_street.getvalue() 
 846   
 847 -    def __setfield_street(self, value): 
 848          if isinstance(value,STRING): 
 849              self.__field_street=value 
 850          else: 
 851              self.__field_street=STRING(value,**{ 'terminator': None,                   'pascal': True }) 
 852   
 853 -    def __delfield_street(self): del self.__field_street 
 854   
 855      street=property(__getfield_street, __setfield_street, __delfield_street, None) 
 856   
 857 -    def __getfield_city(self): 
 858          return self.__field_city.getvalue() 
 859   
 860 -    def __setfield_city(self, value): 
 861          if isinstance(value,STRING): 
 862              self.__field_city=value 
 863          else: 
 864              self.__field_city=STRING(value,**{ 'terminator': None,                   'pascal': True }) 
 865   
 866 -    def __delfield_city(self): del self.__field_city 
 867   
 868      city=property(__getfield_city, __setfield_city, __delfield_city, None) 
 869   
 870 -    def __getfield_state(self): 
 871          return self.__field_state.getvalue() 
 872   
 873 -    def __setfield_state(self, value): 
 874          if isinstance(value,STRING): 
 875              self.__field_state=value 
 876          else: 
 877              self.__field_state=STRING(value,**{ 'terminator': None,                   'pascal': True }) 
 878   
 879 -    def __delfield_state(self): del self.__field_state 
 880   
 881      state=property(__getfield_state, __setfield_state, __delfield_state, None) 
 882   
 883 -    def __getfield_zipcode(self): 
 884          return self.__field_zipcode.getvalue() 
 885   
 886 -    def __setfield_zipcode(self, value): 
 887          if isinstance(value,STRING): 
 888              self.__field_zipcode=value 
 889          else: 
 890              self.__field_zipcode=STRING(value,**{ 'terminator': None,                   'pascal': True }) 
 891   
 892 -    def __delfield_zipcode(self): del self.__field_zipcode 
 893   
 894      zipcode=property(__getfield_zipcode, __setfield_zipcode, __delfield_zipcode, None) 
 895   
 896 -    def __getfield_country(self): 
 897          return self.__field_country.getvalue() 
 898   
 899 -    def __setfield_country(self, value): 
 900          if isinstance(value,STRING): 
 901              self.__field_country=value 
 902          else: 
 903              self.__field_country=STRING(value,**{ 'terminator': None,                   'pascal': True }) 
 904   
 905 -    def __delfield_country(self): del self.__field_country 
 906   
 907      country=property(__getfield_country, __setfield_country, __delfield_country, None) 
 908   
 909 -    def __getfield_cached_wp(self): 
 910          return self.__field_cached_wp.getvalue() 
 911   
 912 -    def __setfield_cached_wp(self, value): 
 913          if isinstance(value,STRING): 
 914              self.__field_cached_wp=value 
 915          else: 
 916              self.__field_cached_wp=STRING(value,**{ 'terminator': None,                   'pascal': True }) 
 917   
 918 -    def __delfield_cached_wp(self): del self.__field_cached_wp 
 919   
 920      cached_wp=property(__getfield_cached_wp, __setfield_cached_wp, __delfield_cached_wp, None) 
 921   
 922 -    def __getfield_cached_wp_num(self): 
 923          return self.__field_cached_wp_num.getvalue() 
 924   
 925 -    def __setfield_cached_wp_num(self, value): 
 926          if isinstance(value,UINT): 
 927              self.__field_cached_wp_num=value 
 928          else: 
 929              self.__field_cached_wp_num=UINT(value,**{'sizeinbytes': 4}) 
 930   
 931 -    def __delfield_cached_wp_num(self): del self.__field_cached_wp_num 
 932   
 933      cached_wp_num=property(__getfield_cached_wp_num, __setfield_cached_wp_num, __delfield_cached_wp_num, None) 
 934   
 935 -    def __getfield_ringtone(self): 
 936          return self.__field_ringtone.getvalue() 
 937   
 938 -    def __setfield_ringtone(self, value): 
 939          if isinstance(value,STRING): 
 940              self.__field_ringtone=value 
 941          else: 
 942              self.__field_ringtone=STRING(value,**{ 'terminator': None,                   'pascal': True }) 
 943   
 944 -    def __delfield_ringtone(self): del self.__field_ringtone 
 945   
 946      ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 
 947   
 948 -    def __getfield_wallpaper(self): 
 949          return self.__field_wallpaper.getvalue() 
 950   
 951 -    def __setfield_wallpaper(self, value): 
 952          if isinstance(value,STRING): 
 953              self.__field_wallpaper=value 
 954          else: 
 955              self.__field_wallpaper=STRING(value,**{ 'terminator': None,                   'pascal': True }) 
 956   
 957 -    def __delfield_wallpaper(self): del self.__field_wallpaper 
 958   
 959      wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None) 
 960   
 961 -    def iscontainer(self): 
 962          return True 
 963   
 964 -    def containerelements(self): 
 965          yield ('info', self.__field_info, None) 
 966          yield ('info2', self.__field_info2, None) 
 967          if self.has_name: 
 968              yield ('name', self.__field_name, None) 
 969          if self.has_email: 
 970              yield ('email', self.__field_email, None) 
 971          if self.has_email2: 
 972              yield ('email2', self.__field_email2, None) 
 973          if self.has_home: 
 974              yield ('home', self.__field_home, None) 
 975          if self.has_work: 
 976              yield ('work', self.__field_work, None) 
 977          if self.has_cell: 
 978              yield ('cell', self.__field_cell, None) 
 979          if self.has_fax: 
 980              yield ('fax', self.__field_fax, None) 
 981          if self.has_cell2: 
 982              yield ('cell2', self.__field_cell2, None) 
 983          if self.has_note: 
 984              yield ('note', self.__field_note, None) 
 985          if self.has_date: 
 986              yield ('datetime', self.__field_datetime, None) 
 987          if self.has_group: 
 988              yield ('group', self.__field_group, None) 
 989          if self.has_im_name: 
 990              yield ('im_name', self.__field_im_name, None) 
 991              yield ('im_type', self.__field_im_type, None) 
 992          if self.has_street: 
 993              yield ('street', self.__field_street, None) 
 994          if self.has_city: 
 995              yield ('city', self.__field_city, None) 
 996          if self.has_state: 
 997              yield ('state', self.__field_state, None) 
 998          if self.has_zipcode: 
 999              yield ('zipcode', self.__field_zipcode, None) 
1000          if self.has_country: 
1001              yield ('country', self.__field_country, None) 
1002          if self.has_cached_wp: 
1003              yield ('cached_wp', self.__field_cached_wp, None) 
1004              yield ('cached_wp_num', self.__field_cached_wp_num, None) 
1005          if self.has_ringtone: 
1006              yield ('ringtone', self.__field_ringtone, None) 
1007          if self.has_wallpaper: 
1008              yield ('wallpaper', self.__field_wallpaper, None) 
1009   
1010      @property 
1011 -    def has_name(self): 
1012          return bool(self.info & PB_FLG_NAME) 
1013      @property 
1014 -    def has_email(self): 
1015          return bool(self.info & PB_FLG_EMAIL) 
1016      @property 
1017 -    def has_email2(self): 
1018          return bool(self.info & PB_FLG_EMAIL2) 
1019      @property 
1020 -    def has_home(self): 
1021          return bool(self.info & PB_FLG_HOME) 
1022      @property 
1023 -    def has_work(self): 
1024          return bool(self.info & PB_FLG_WORK) 
1025      @property 
1026 -    def has_cell(self): 
1027          return bool(self.info & PB_FLG_CELL) 
1028      @property 
1029 -    def has_fax(self): 
1030          return bool(self.info & PB_FLG_FAX) 
1031      @property 
1032 -    def has_cell2(self): 
1033          return bool(self.info & PB_FLG_CELL2) 
1034      @property 
1035 -    def has_note(self): 
1036          return bool(self.info & PB_FLG_NOTE) 
1037      @property 
1038 -    def has_date(self): 
1039          return bool(self.info & PB_FLG_DATE) 
1040      @property 
1041 -    def has_group(self): 
1042          return bool(self.info & PB_FLG_GROUP) 
1043      @property 
1044 -    def has_im_name(self): 
1045          return bool((self.info & PB_FLG_IMNAME1) and (self.info2 & PB_FLG_IMNAME2)) 
1046      @property 
1047 -    def has_street(self): 
1048          return bool(self.info2 & PB_FLG_STREET) 
1049      @property 
1050 -    def has_city(self): 
1051          return bool(self.info2 & PB_FLG_CITY) 
1052      @property 
1053 -    def has_state(self): 
1054          return bool(self.info2 & PB_FLG_STATE) 
1055      @property 
1056 -    def has_zipcode(self): 
1057          return bool(self.info2 & PB_FLG_ZIP) 
1058      @property 
1059 -    def has_country(self): 
1060          return bool(self.info2 & PB_FLG_COUNTRY) 
1061      @property 
1062 -    def has_cached_wp(self): 
1063          return bool(self.info2 & PB_FLG_ENTRY_CACHED_WP) 
1064      @property 
1065 -    def has_ringtone(self): 
1066          return bool(self.info2 & PB_FLG_ENTRY_RT) 
1067      @property 
1068 -    def has_wallpaper(self): 
1069          return bool(self.info2 & PB_FLG_ENTRY_WP) 
1070      @property 
1071 -    def has_address(self): 
1072          # return True if this has at least one valid address item 
1073          return self.has_street or self.has_city or self.has_state or \ 
1074                 self.has_zipcode or self.has_country 
1075      @property 
1076 -    def address(self): 
1077          # return the address in a BitPim phonebook addresses dict 
1078          _addr={} 
1079          if self.has_street: 
1080              _addr['street']=self.street 
1081          if self.has_city: 
1082              _addr['city']=self.city 
1083          if self.has_state: 
1084              _addr['state']=self.state 
1085          if self.has_zipcode: 
1086              _addr['postalcode']=self.zipcode 
1087          if self.has_country: 
1088              _addr['country']=self.country 
1089          return _addr 
1090   
1091   
1092   
1093   
1094 -class LenEntry(BaseProtogenClass): 
1095      # Read-From-Buffer-Only Class 
1096      __fields=['itemlen'] 
1097   
1098 -    def __init__(self, *args, **kwargs): 
1099          dict={} 
1100          # What was supplied to this function 
1101          dict.update(kwargs) 
1102          # Parent constructor 
1103          super(LenEntry,self).__init__(**dict) 
1104          if self.__class__ is LenEntry: 
1105              self._update(args,dict) 
1106   
1107   
1108 -    def getfields(self): 
1109          return self.__fields 
1110   
1111   
1112 -    def _update(self, args, kwargs): 
1113          super(LenEntry,self)._update(args,kwargs) 
1114          keys=kwargs.keys() 
1115          for key in keys: 
1116              if key in self.__fields: 
1117                  setattr(self, key, kwargs[key]) 
1118                  del kwargs[key] 
1119          # Were any unrecognized kwargs passed in? 
1120          if __debug__: 
1121              self._complainaboutunusedargs(LenEntry,kwargs) 
1122          if len(args): 
1123              dict2={'sizeinbytes': 2,  'default': 0 } 
1124              dict2.update(kwargs) 
1125              kwargs=dict2 
1126              self.__field_itemlen=UINT(*args,**dict2) 
1127          # Make all P fields that haven't already been constructed 
1128   
1129   
1130 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1131          'Writes this packet to the supplied buffer' 
1132          raise NotImplementedError 
1133   
1134   
1135 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1136          'Reads this packet from the supplied buffer' 
1137          self._bufferstartoffset=buf.getcurrentoffset() 
1138          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1139          self.__field_itemlen=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1140          self.__field_itemlen.readfrombuffer(buf) 
1141          self._bufferendoffset=buf.getcurrentoffset() 
1142   
1143   
1144 -    def __getfield_itemlen(self): 
1145          try: self.__field_itemlen 
1146          except: 
1147              self.__field_itemlen=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1148          return self.__field_itemlen.getvalue() 
1149   
1150 -    def __setfield_itemlen(self, value): 
1151          if isinstance(value,UINT): 
1152              self.__field_itemlen=value 
1153          else: 
1154              self.__field_itemlen=UINT(value,**{'sizeinbytes': 2,  'default': 0 }) 
1155   
1156 -    def __delfield_itemlen(self): del self.__field_itemlen 
1157   
1158      itemlen=property(__getfield_itemlen, __setfield_itemlen, __delfield_itemlen, None) 
1159   
1160 -    def iscontainer(self): 
1161          return True 
1162   
1163 -    def containerelements(self): 
1164          yield ('itemlen', self.__field_itemlen, None) 
1165   
1166   
1167   
1168   
1169 -class PBFile(BaseProtogenClass): 
1170      # Read-From-Buffer-Only Class 
1171      __fields=['lens', 'items'] 
1172   
1173 -    def __init__(self, *args, **kwargs): 
1174          dict={} 
1175          # What was supplied to this function 
1176          dict.update(kwargs) 
1177          # Parent constructor 
1178          super(PBFile,self).__init__(**dict) 
1179          if self.__class__ is PBFile: 
1180              self._update(args,dict) 
1181   
1182   
1183 -    def getfields(self): 
1184          return self.__fields 
1185   
1186   
1187 -    def _update(self, args, kwargs): 
1188          super(PBFile,self)._update(args,kwargs) 
1189          keys=kwargs.keys() 
1190          for key in keys: 
1191              if key in self.__fields: 
1192                  setattr(self, key, kwargs[key]) 
1193                  del kwargs[key] 
1194          # Were any unrecognized kwargs passed in? 
1195          if __debug__: 
1196              self._complainaboutunusedargs(PBFile,kwargs) 
1197          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1198          # Make all P fields that haven't already been constructed 
1199   
1200   
1201 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1202          'Writes this packet to the supplied buffer' 
1203          raise NotImplementedError 
1204   
1205   
1206 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1207          'Reads this packet from the supplied buffer' 
1208          self._bufferstartoffset=buf.getcurrentoffset() 
1209          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1210          self.__field_lens=LIST(**{ 'elementclass': LenEntry,             'length': 8,             'createdefault': True }) 
1211          self.__field_lens.readfrombuffer(buf) 
1212          self.__field_items=LIST(**{ 'elementclass': PBEntry }) 
1213          self.__field_items.readfrombuffer(buf) 
1214          self._bufferendoffset=buf.getcurrentoffset() 
1215   
1216   
1217 -    def __getfield_lens(self): 
1218          try: self.__field_lens 
1219          except: 
1220              self.__field_lens=LIST(**{ 'elementclass': LenEntry,             'length': 8,             'createdefault': True }) 
1221          return self.__field_lens.getvalue() 
1222   
1223 -    def __setfield_lens(self, value): 
1224          if isinstance(value,LIST): 
1225              self.__field_lens=value 
1226          else: 
1227              self.__field_lens=LIST(value,**{ 'elementclass': LenEntry,             'length': 8,             'createdefault': True }) 
1228   
1229 -    def __delfield_lens(self): del self.__field_lens 
1230   
1231      lens=property(__getfield_lens, __setfield_lens, __delfield_lens, None) 
1232   
1233 -    def __getfield_items(self): 
1234          try: self.__field_items 
1235          except: 
1236              self.__field_items=LIST(**{ 'elementclass': PBEntry }) 
1237          return self.__field_items.getvalue() 
1238   
1239 -    def __setfield_items(self, value): 
1240          if isinstance(value,LIST): 
1241              self.__field_items=value 
1242          else: 
1243              self.__field_items=LIST(value,**{ 'elementclass': PBEntry }) 
1244   
1245 -    def __delfield_items(self): del self.__field_items 
1246   
1247      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
1248   
1249 -    def iscontainer(self): 
1250          return True 
1251   
1252 -    def containerelements(self): 
1253          yield ('lens', self.__field_lens, None) 
1254          yield ('items', self.__field_items, None) 
1255   
1256   
1257   
1258   
1259 -class PBFileHeader(BaseProtogenClass): 
1260      # Read-From-Buffer-Only Class 
1261      __fields=['lens'] 
1262   
1263 -    def __init__(self, *args, **kwargs): 
1264          dict={} 
1265          # What was supplied to this function 
1266          dict.update(kwargs) 
1267          # Parent constructor 
1268          super(PBFileHeader,self).__init__(**dict) 
1269          if self.__class__ is PBFileHeader: 
1270              self._update(args,dict) 
1271   
1272   
1273 -    def getfields(self): 
1274          return self.__fields 
1275   
1276   
1277 -    def _update(self, args, kwargs): 
1278          super(PBFileHeader,self)._update(args,kwargs) 
1279          keys=kwargs.keys() 
1280          for key in keys: 
1281              if key in self.__fields: 
1282                  setattr(self, key, kwargs[key]) 
1283                  del kwargs[key] 
1284          # Were any unrecognized kwargs passed in? 
1285          if __debug__: 
1286              self._complainaboutunusedargs(PBFileHeader,kwargs) 
1287          if len(args): 
1288              dict2={ 'elementclass': LenEntry,             'length': 8,             'createdefault': True } 
1289              dict2.update(kwargs) 
1290              kwargs=dict2 
1291              self.__field_lens=LIST(*args,**dict2) 
1292          # Make all P fields that haven't already been constructed 
1293   
1294   
1295 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1296          'Writes this packet to the supplied buffer' 
1297          raise NotImplementedError 
1298   
1299   
1300 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1301          'Reads this packet from the supplied buffer' 
1302          self._bufferstartoffset=buf.getcurrentoffset() 
1303          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1304          self.__field_lens=LIST(**{ 'elementclass': LenEntry,             'length': 8,             'createdefault': True }) 
1305          self.__field_lens.readfrombuffer(buf) 
1306          self._bufferendoffset=buf.getcurrentoffset() 
1307   
1308   
1309 -    def __getfield_lens(self): 
1310          try: self.__field_lens 
1311          except: 
1312              self.__field_lens=LIST(**{ 'elementclass': LenEntry,             'length': 8,             'createdefault': True }) 
1313          return self.__field_lens.getvalue() 
1314   
1315 -    def __setfield_lens(self, value): 
1316          if isinstance(value,LIST): 
1317              self.__field_lens=value 
1318          else: 
1319              self.__field_lens=LIST(value,**{ 'elementclass': LenEntry,             'length': 8,             'createdefault': True }) 
1320   
1321 -    def __delfield_lens(self): del self.__field_lens 
1322   
1323      lens=property(__getfield_lens, __setfield_lens, __delfield_lens, None) 
1324   
1325 -    def iscontainer(self): 
1326          return True 
1327   
1328 -    def containerelements(self): 
1329          yield ('lens', self.__field_lens, None) 
1330   
1331   
1332   
1333   
1334 -class ss_cmd_hdr(BaseProtogenClass): 
1335      __fields=['commandcode', 'command'] 
1336   
1337 -    def __init__(self, *args, **kwargs): 
1338          dict={} 
1339          # What was supplied to this function 
1340          dict.update(kwargs) 
1341          # Parent constructor 
1342          super(ss_cmd_hdr,self).__init__(**dict) 
1343          if self.__class__ is ss_cmd_hdr: 
1344              self._update(args,dict) 
1345   
1346   
1347 -    def getfields(self): 
1348          return self.__fields 
1349   
1350   
1351 -    def _update(self, args, kwargs): 
1352          super(ss_cmd_hdr,self)._update(args,kwargs) 
1353          keys=kwargs.keys() 
1354          for key in keys: 
1355              if key in self.__fields: 
1356                  setattr(self, key, kwargs[key]) 
1357                  del kwargs[key] 
1358          # Were any unrecognized kwargs passed in? 
1359          if __debug__: 
1360              self._complainaboutunusedargs(ss_cmd_hdr,kwargs) 
1361          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1362          # Make all P fields that haven't already been constructed 
1363   
1364   
1365 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1366          'Writes this packet to the supplied buffer' 
1367          self._bufferstartoffset=buf.getcurrentoffset() 
1368          try: self.__field_commandcode 
1369          except: 
1370              self.__field_commandcode=UINT(**{'sizeinbytes': 4,  'default': 0xfb4b }) 
1371          self.__field_commandcode.writetobuffer(buf) 
1372          self.__field_command.writetobuffer(buf) 
1373          self._bufferendoffset=buf.getcurrentoffset() 
1374          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1375   
1376   
1377 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1378          'Reads this packet from the supplied buffer' 
1379          self._bufferstartoffset=buf.getcurrentoffset() 
1380          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1381          self.__field_commandcode=UINT(**{'sizeinbytes': 4,  'default': 0xfb4b }) 
1382          self.__field_commandcode.readfrombuffer(buf) 
1383          self.__field_command=UINT(**{'sizeinbytes': 1}) 
1384          self.__field_command.readfrombuffer(buf) 
1385          self._bufferendoffset=buf.getcurrentoffset() 
1386   
1387   
1388 -    def __getfield_commandcode(self): 
1389          try: self.__field_commandcode 
1390          except: 
1391              self.__field_commandcode=UINT(**{'sizeinbytes': 4,  'default': 0xfb4b }) 
1392          return self.__field_commandcode.getvalue() 
1393   
1394 -    def __setfield_commandcode(self, value): 
1395          if isinstance(value,UINT): 
1396              self.__field_commandcode=value 
1397          else: 
1398              self.__field_commandcode=UINT(value,**{'sizeinbytes': 4,  'default': 0xfb4b }) 
1399   
1400 -    def __delfield_commandcode(self): del self.__field_commandcode 
1401   
1402      commandcode=property(__getfield_commandcode, __setfield_commandcode, __delfield_commandcode, None) 
1403   
1404 -    def __getfield_command(self): 
1405          return self.__field_command.getvalue() 
1406   
1407 -    def __setfield_command(self, value): 
1408          if isinstance(value,UINT): 
1409              self.__field_command=value 
1410          else: 
1411              self.__field_command=UINT(value,**{'sizeinbytes': 1}) 
1412   
1413 -    def __delfield_command(self): del self.__field_command 
1414   
1415      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
1416   
1417 -    def iscontainer(self): 
1418          return True 
1419   
1420 -    def containerelements(self): 
1421          yield ('commandcode', self.__field_commandcode, None) 
1422          yield ('command', self.__field_command, None) 
1423   
1424   
1425   
1426   
1427 -class ss_cmd_resp(BaseProtogenClass): 
1428      __fields=['cmd_hdr', 'data'] 
1429   
1430 -    def __init__(self, *args, **kwargs): 
1431          dict={} 
1432          # What was supplied to this function 
1433          dict.update(kwargs) 
1434          # Parent constructor 
1435          super(ss_cmd_resp,self).__init__(**dict) 
1436          if self.__class__ is ss_cmd_resp: 
1437              self._update(args,dict) 
1438   
1439   
1440 -    def getfields(self): 
1441          return self.__fields 
1442   
1443   
1444 -    def _update(self, args, kwargs): 
1445          super(ss_cmd_resp,self)._update(args,kwargs) 
1446          keys=kwargs.keys() 
1447          for key in keys: 
1448              if key in self.__fields: 
1449                  setattr(self, key, kwargs[key]) 
1450                  del kwargs[key] 
1451          # Were any unrecognized kwargs passed in? 
1452          if __debug__: 
1453              self._complainaboutunusedargs(ss_cmd_resp,kwargs) 
1454          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1455          # Make all P fields that haven't already been constructed 
1456   
1457   
1458 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1459          'Writes this packet to the supplied buffer' 
1460          self._bufferstartoffset=buf.getcurrentoffset() 
1461          self.__field_cmd_hdr.writetobuffer(buf) 
1462          self.__field_data.writetobuffer(buf) 
1463          self._bufferendoffset=buf.getcurrentoffset() 
1464          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1465   
1466   
1467 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1468          'Reads this packet from the supplied buffer' 
1469          self._bufferstartoffset=buf.getcurrentoffset() 
1470          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1471          self.__field_cmd_hdr=ss_cmd_hdr() 
1472          self.__field_cmd_hdr.readfrombuffer(buf) 
1473          self.__field_data=DATA() 
1474          self.__field_data.readfrombuffer(buf) 
1475          self._bufferendoffset=buf.getcurrentoffset() 
1476   
1477   
1478 -    def __getfield_cmd_hdr(self): 
1479          return self.__field_cmd_hdr.getvalue() 
1480   
1481 -    def __setfield_cmd_hdr(self, value): 
1482          if isinstance(value,ss_cmd_hdr): 
1483              self.__field_cmd_hdr=value 
1484          else: 
1485              self.__field_cmd_hdr=ss_cmd_hdr(value,) 
1486   
1487 -    def __delfield_cmd_hdr(self): del self.__field_cmd_hdr 
1488   
1489      cmd_hdr=property(__getfield_cmd_hdr, __setfield_cmd_hdr, __delfield_cmd_hdr, None) 
1490   
1491 -    def __getfield_data(self): 
1492          return self.__field_data.getvalue() 
1493   
1494 -    def __setfield_data(self, value): 
1495          if isinstance(value,DATA): 
1496              self.__field_data=value 
1497          else: 
1498              self.__field_data=DATA(value,) 
1499   
1500 -    def __delfield_data(self): del self.__field_data 
1501   
1502      data=property(__getfield_data, __setfield_data, __delfield_data, None) 
1503   
1504 -    def iscontainer(self): 
1505          return True 
1506   
1507 -    def containerelements(self): 
1508          yield ('cmd_hdr', self.__field_cmd_hdr, None) 
1509          yield ('data', self.__field_data, None) 
1510   
1511   
1512   
1513   
1514 -class ss_sw_req(BaseProtogenClass): 
1515      __fields=['hdr'] 
1516   
1517 -    def __init__(self, *args, **kwargs): 
1518          dict={} 
1519          # What was supplied to this function 
1520          dict.update(kwargs) 
1521          # Parent constructor 
1522          super(ss_sw_req,self).__init__(**dict) 
1523          if self.__class__ is ss_sw_req: 
1524              self._update(args,dict) 
1525   
1526   
1527 -    def getfields(self): 
1528          return self.__fields 
1529   
1530   
1531 -    def _update(self, args, kwargs): 
1532          super(ss_sw_req,self)._update(args,kwargs) 
1533          keys=kwargs.keys() 
1534          for key in keys: 
1535              if key in self.__fields: 
1536                  setattr(self, key, kwargs[key]) 
1537                  del kwargs[key] 
1538          # Were any unrecognized kwargs passed in? 
1539          if __debug__: 
1540              self._complainaboutunusedargs(ss_sw_req,kwargs) 
1541          if len(args): 
1542              dict2={ 'command': SS_CMD_SW_VERSION } 
1543              dict2.update(kwargs) 
1544              kwargs=dict2 
1545              self.__field_hdr=ss_cmd_hdr(*args,**dict2) 
1546          # Make all P fields that haven't already been constructed 
1547   
1548   
1549 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1550          'Writes this packet to the supplied buffer' 
1551          self._bufferstartoffset=buf.getcurrentoffset() 
1552          try: self.__field_hdr 
1553          except: 
1554              self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_SW_VERSION }) 
1555          self.__field_hdr.writetobuffer(buf) 
1556          self._bufferendoffset=buf.getcurrentoffset() 
1557          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1558   
1559   
1560 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1561          'Reads this packet from the supplied buffer' 
1562          self._bufferstartoffset=buf.getcurrentoffset() 
1563          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1564          self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_SW_VERSION }) 
1565          self.__field_hdr.readfrombuffer(buf) 
1566          self._bufferendoffset=buf.getcurrentoffset() 
1567   
1568   
1569 -    def __getfield_hdr(self): 
1570          try: self.__field_hdr 
1571          except: 
1572              self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_SW_VERSION }) 
1573          return self.__field_hdr.getvalue() 
1574   
1575 -    def __setfield_hdr(self, value): 
1576          if isinstance(value,ss_cmd_hdr): 
1577              self.__field_hdr=value 
1578          else: 
1579              self.__field_hdr=ss_cmd_hdr(value,**{ 'command': SS_CMD_SW_VERSION }) 
1580   
1581 -    def __delfield_hdr(self): del self.__field_hdr 
1582   
1583      hdr=property(__getfield_hdr, __setfield_hdr, __delfield_hdr, None) 
1584   
1585 -    def iscontainer(self): 
1586          return True 
1587   
1588 -    def containerelements(self): 
1589          yield ('hdr', self.__field_hdr, None) 
1590   
1591   
1592   
1593   
1594 -class ss_sw_resp(BaseProtogenClass): 
1595      # Read-From-Buffer-Only Class 
1596      __fields=['hdr', 'sw_version'] 
1597   
1598 -    def __init__(self, *args, **kwargs): 
1599          dict={} 
1600          # What was supplied to this function 
1601          dict.update(kwargs) 
1602          # Parent constructor 
1603          super(ss_sw_resp,self).__init__(**dict) 
1604          if self.__class__ is ss_sw_resp: 
1605              self._update(args,dict) 
1606   
1607   
1608 -    def getfields(self): 
1609          return self.__fields 
1610   
1611   
1612 -    def _update(self, args, kwargs): 
1613          super(ss_sw_resp,self)._update(args,kwargs) 
1614          keys=kwargs.keys() 
1615          for key in keys: 
1616              if key in self.__fields: 
1617                  setattr(self, key, kwargs[key]) 
1618                  del kwargs[key] 
1619          # Were any unrecognized kwargs passed in? 
1620          if __debug__: 
1621              self._complainaboutunusedargs(ss_sw_resp,kwargs) 
1622          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1623          # Make all P fields that haven't already been constructed 
1624   
1625   
1626 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1627          'Writes this packet to the supplied buffer' 
1628          raise NotImplementedError 
1629   
1630   
1631 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1632          'Reads this packet from the supplied buffer' 
1633          self._bufferstartoffset=buf.getcurrentoffset() 
1634          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1635          self.__field_hdr=ss_cmd_hdr() 
1636          self.__field_hdr.readfrombuffer(buf) 
1637          self.__field_sw_version=STRING(**{ 'terminator': 0 }) 
1638          self.__field_sw_version.readfrombuffer(buf) 
1639          self._bufferendoffset=buf.getcurrentoffset() 
1640   
1641   
1642 -    def __getfield_hdr(self): 
1643          return self.__field_hdr.getvalue() 
1644   
1645 -    def __setfield_hdr(self, value): 
1646          if isinstance(value,ss_cmd_hdr): 
1647              self.__field_hdr=value 
1648          else: 
1649              self.__field_hdr=ss_cmd_hdr(value,) 
1650   
1651 -    def __delfield_hdr(self): del self.__field_hdr 
1652   
1653      hdr=property(__getfield_hdr, __setfield_hdr, __delfield_hdr, None) 
1654   
1655 -    def __getfield_sw_version(self): 
1656          return self.__field_sw_version.getvalue() 
1657   
1658 -    def __setfield_sw_version(self, value): 
1659          if isinstance(value,STRING): 
1660              self.__field_sw_version=value 
1661          else: 
1662              self.__field_sw_version=STRING(value,**{ 'terminator': 0 }) 
1663   
1664 -    def __delfield_sw_version(self): del self.__field_sw_version 
1665   
1666      sw_version=property(__getfield_sw_version, __setfield_sw_version, __delfield_sw_version, None) 
1667   
1668 -    def iscontainer(self): 
1669          return True 
1670   
1671 -    def containerelements(self): 
1672          yield ('hdr', self.__field_hdr, None) 
1673          yield ('sw_version', self.__field_sw_version, None) 
1674   
1675   
1676   
1677   
1678 -class ss_hw_req(BaseProtogenClass): 
1679      __fields=['hdr'] 
1680   
1681 -    def __init__(self, *args, **kwargs): 
1682          dict={} 
1683          # What was supplied to this function 
1684          dict.update(kwargs) 
1685          # Parent constructor 
1686          super(ss_hw_req,self).__init__(**dict) 
1687          if self.__class__ is ss_hw_req: 
1688              self._update(args,dict) 
1689   
1690   
1691 -    def getfields(self): 
1692          return self.__fields 
1693   
1694   
1695 -    def _update(self, args, kwargs): 
1696          super(ss_hw_req,self)._update(args,kwargs) 
1697          keys=kwargs.keys() 
1698          for key in keys: 
1699              if key in self.__fields: 
1700                  setattr(self, key, kwargs[key]) 
1701                  del kwargs[key] 
1702          # Were any unrecognized kwargs passed in? 
1703          if __debug__: 
1704              self._complainaboutunusedargs(ss_hw_req,kwargs) 
1705          if len(args): 
1706              dict2={ 'command': SS_CMD_HW_VERSION } 
1707              dict2.update(kwargs) 
1708              kwargs=dict2 
1709              self.__field_hdr=ss_cmd_hdr(*args,**dict2) 
1710          # Make all P fields that haven't already been constructed 
1711   
1712   
1713 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1714          'Writes this packet to the supplied buffer' 
1715          self._bufferstartoffset=buf.getcurrentoffset() 
1716          try: self.__field_hdr 
1717          except: 
1718              self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_HW_VERSION }) 
1719          self.__field_hdr.writetobuffer(buf) 
1720          self._bufferendoffset=buf.getcurrentoffset() 
1721          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1722   
1723   
1724 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1725          'Reads this packet from the supplied buffer' 
1726          self._bufferstartoffset=buf.getcurrentoffset() 
1727          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1728          self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_HW_VERSION }) 
1729          self.__field_hdr.readfrombuffer(buf) 
1730          self._bufferendoffset=buf.getcurrentoffset() 
1731   
1732   
1733 -    def __getfield_hdr(self): 
1734          try: self.__field_hdr 
1735          except: 
1736              self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_HW_VERSION }) 
1737          return self.__field_hdr.getvalue() 
1738   
1739 -    def __setfield_hdr(self, value): 
1740          if isinstance(value,ss_cmd_hdr): 
1741              self.__field_hdr=value 
1742          else: 
1743              self.__field_hdr=ss_cmd_hdr(value,**{ 'command': SS_CMD_HW_VERSION }) 
1744   
1745 -    def __delfield_hdr(self): del self.__field_hdr 
1746   
1747      hdr=property(__getfield_hdr, __setfield_hdr, __delfield_hdr, None) 
1748   
1749 -    def iscontainer(self): 
1750          return True 
1751   
1752 -    def containerelements(self): 
1753          yield ('hdr', self.__field_hdr, None) 
1754   
1755   
1756   
1757   
1758 -class ss_hw_resp(BaseProtogenClass): 
1759      # Read-From-Buffer-Only Class 
1760      __fields=['hdr', 'hw_version'] 
1761   
1762 -    def __init__(self, *args, **kwargs): 
1763          dict={} 
1764          # What was supplied to this function 
1765          dict.update(kwargs) 
1766          # Parent constructor 
1767          super(ss_hw_resp,self).__init__(**dict) 
1768          if self.__class__ is ss_hw_resp: 
1769              self._update(args,dict) 
1770   
1771   
1772 -    def getfields(self): 
1773          return self.__fields 
1774   
1775   
1776 -    def _update(self, args, kwargs): 
1777          super(ss_hw_resp,self)._update(args,kwargs) 
1778          keys=kwargs.keys() 
1779          for key in keys: 
1780              if key in self.__fields: 
1781                  setattr(self, key, kwargs[key]) 
1782                  del kwargs[key] 
1783          # Were any unrecognized kwargs passed in? 
1784          if __debug__: 
1785              self._complainaboutunusedargs(ss_hw_resp,kwargs) 
1786          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1787          # Make all P fields that haven't already been constructed 
1788   
1789   
1790 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1791          'Writes this packet to the supplied buffer' 
1792          raise NotImplementedError 
1793   
1794   
1795 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1796          'Reads this packet from the supplied buffer' 
1797          self._bufferstartoffset=buf.getcurrentoffset() 
1798          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1799          self.__field_hdr=ss_cmd_hdr() 
1800          self.__field_hdr.readfrombuffer(buf) 
1801          self.__field_hw_version=STRING(**{ 'terminator': 0 }) 
1802          self.__field_hw_version.readfrombuffer(buf) 
1803          self._bufferendoffset=buf.getcurrentoffset() 
1804   
1805   
1806 -    def __getfield_hdr(self): 
1807          return self.__field_hdr.getvalue() 
1808   
1809 -    def __setfield_hdr(self, value): 
1810          if isinstance(value,ss_cmd_hdr): 
1811              self.__field_hdr=value 
1812          else: 
1813              self.__field_hdr=ss_cmd_hdr(value,) 
1814   
1815 -    def __delfield_hdr(self): del self.__field_hdr 
1816   
1817      hdr=property(__getfield_hdr, __setfield_hdr, __delfield_hdr, None) 
1818   
1819 -    def __getfield_hw_version(self): 
1820          return self.__field_hw_version.getvalue() 
1821   
1822 -    def __setfield_hw_version(self, value): 
1823          if isinstance(value,STRING): 
1824              self.__field_hw_version=value 
1825          else: 
1826              self.__field_hw_version=STRING(value,**{ 'terminator': 0 }) 
1827   
1828 -    def __delfield_hw_version(self): del self.__field_hw_version 
1829   
1830      hw_version=property(__getfield_hw_version, __setfield_hw_version, __delfield_hw_version, None) 
1831   
1832 -    def iscontainer(self): 
1833          return True 
1834   
1835 -    def containerelements(self): 
1836          yield ('hdr', self.__field_hdr, None) 
1837          yield ('hw_version', self.__field_hw_version, None) 
1838   
1839   
1840   
1841   
1842 -class ss_pb_count_req(BaseProtogenClass): 
1843      __fields=['hdr'] 
1844   
1845 -    def __init__(self, *args, **kwargs): 
1846          dict={} 
1847          # What was supplied to this function 
1848          dict.update(kwargs) 
1849          # Parent constructor 
1850          super(ss_pb_count_req,self).__init__(**dict) 
1851          if self.__class__ is ss_pb_count_req: 
1852              self._update(args,dict) 
1853   
1854   
1855 -    def getfields(self): 
1856          return self.__fields 
1857   
1858   
1859 -    def _update(self, args, kwargs): 
1860          super(ss_pb_count_req,self)._update(args,kwargs) 
1861          keys=kwargs.keys() 
1862          for key in keys: 
1863              if key in self.__fields: 
1864                  setattr(self, key, kwargs[key]) 
1865                  del kwargs[key] 
1866          # Were any unrecognized kwargs passed in? 
1867          if __debug__: 
1868              self._complainaboutunusedargs(ss_pb_count_req,kwargs) 
1869          if len(args): 
1870              dict2={ 'command': SS_CMD_PB_COUNT } 
1871              dict2.update(kwargs) 
1872              kwargs=dict2 
1873              self.__field_hdr=ss_cmd_hdr(*args,**dict2) 
1874          # Make all P fields that haven't already been constructed 
1875   
1876   
1877 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1878          'Writes this packet to the supplied buffer' 
1879          self._bufferstartoffset=buf.getcurrentoffset() 
1880          try: self.__field_hdr 
1881          except: 
1882              self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_COUNT }) 
1883          self.__field_hdr.writetobuffer(buf) 
1884          self._bufferendoffset=buf.getcurrentoffset() 
1885          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1886   
1887   
1888 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1889          'Reads this packet from the supplied buffer' 
1890          self._bufferstartoffset=buf.getcurrentoffset() 
1891          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1892          self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_COUNT }) 
1893          self.__field_hdr.readfrombuffer(buf) 
1894          self._bufferendoffset=buf.getcurrentoffset() 
1895   
1896   
1897 -    def __getfield_hdr(self): 
1898          try: self.__field_hdr 
1899          except: 
1900              self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_COUNT }) 
1901          return self.__field_hdr.getvalue() 
1902   
1903 -    def __setfield_hdr(self, value): 
1904          if isinstance(value,ss_cmd_hdr): 
1905              self.__field_hdr=value 
1906          else: 
1907              self.__field_hdr=ss_cmd_hdr(value,**{ 'command': SS_CMD_PB_COUNT }) 
1908   
1909 -    def __delfield_hdr(self): del self.__field_hdr 
1910   
1911      hdr=property(__getfield_hdr, __setfield_hdr, __delfield_hdr, None) 
1912   
1913 -    def iscontainer(self): 
1914          return True 
1915   
1916 -    def containerelements(self): 
1917          yield ('hdr', self.__field_hdr, None) 
1918   
1919   
1920   
1921   
1922 -class ss_pb_count_resp(BaseProtogenClass): 
1923      # Read-From-Buffer-Only Class 
1924      __fields=['hdr', 'count'] 
1925   
1926 -    def __init__(self, *args, **kwargs): 
1927          dict={} 
1928          # What was supplied to this function 
1929          dict.update(kwargs) 
1930          # Parent constructor 
1931          super(ss_pb_count_resp,self).__init__(**dict) 
1932          if self.__class__ is ss_pb_count_resp: 
1933              self._update(args,dict) 
1934   
1935   
1936 -    def getfields(self): 
1937          return self.__fields 
1938   
1939   
1940 -    def _update(self, args, kwargs): 
1941          super(ss_pb_count_resp,self)._update(args,kwargs) 
1942          keys=kwargs.keys() 
1943          for key in keys: 
1944              if key in self.__fields: 
1945                  setattr(self, key, kwargs[key]) 
1946                  del kwargs[key] 
1947          # Were any unrecognized kwargs passed in? 
1948          if __debug__: 
1949              self._complainaboutunusedargs(ss_pb_count_resp,kwargs) 
1950          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1951          # Make all P fields that haven't already been constructed 
1952   
1953   
1954 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1955          'Writes this packet to the supplied buffer' 
1956          raise NotImplementedError 
1957   
1958   
1959 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1960          'Reads this packet from the supplied buffer' 
1961          self._bufferstartoffset=buf.getcurrentoffset() 
1962          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1963          self.__field_hdr=ss_cmd_hdr() 
1964          self.__field_hdr.readfrombuffer(buf) 
1965          DONTCARE(**{'sizeinbytes': 1}).readfrombuffer(buf) 
1966          self.__field_count=UINT(**{'sizeinbytes': 2}) 
1967          self.__field_count.readfrombuffer(buf) 
1968          self._bufferendoffset=buf.getcurrentoffset() 
1969   
1970   
1971 -    def __getfield_hdr(self): 
1972          return self.__field_hdr.getvalue() 
1973   
1974 -    def __setfield_hdr(self, value): 
1975          if isinstance(value,ss_cmd_hdr): 
1976              self.__field_hdr=value 
1977          else: 
1978              self.__field_hdr=ss_cmd_hdr(value,) 
1979   
1980 -    def __delfield_hdr(self): del self.__field_hdr 
1981   
1982      hdr=property(__getfield_hdr, __setfield_hdr, __delfield_hdr, None) 
1983   
1984 -    def __getfield_count(self): 
1985          return self.__field_count.getvalue() 
1986   
1987 -    def __setfield_count(self, value): 
1988          if isinstance(value,UINT): 
1989              self.__field_count=value 
1990          else: 
1991              self.__field_count=UINT(value,**{'sizeinbytes': 2}) 
1992   
1993 -    def __delfield_count(self): del self.__field_count 
1994   
1995      count=property(__getfield_count, __setfield_count, __delfield_count, None) 
1996   
1997 -    def iscontainer(self): 
1998          return True 
1999   
2000 -    def containerelements(self): 
2001          yield ('hdr', self.__field_hdr, None) 
2002          yield ('count', self.__field_count, None) 
2003   
2004   
2005   
2006   
2007 -class ss_pb_read_req(BaseProtogenClass): 
2008      __fields=['hdr', 'index'] 
2009   
2010 -    def __init__(self, *args, **kwargs): 
2011          dict={} 
2012          # What was supplied to this function 
2013          dict.update(kwargs) 
2014          # Parent constructor 
2015          super(ss_pb_read_req,self).__init__(**dict) 
2016          if self.__class__ is ss_pb_read_req: 
2017              self._update(args,dict) 
2018   
2019   
2020 -    def getfields(self): 
2021          return self.__fields 
2022   
2023   
2024 -    def _update(self, args, kwargs): 
2025          super(ss_pb_read_req,self)._update(args,kwargs) 
2026          keys=kwargs.keys() 
2027          for key in keys: 
2028              if key in self.__fields: 
2029                  setattr(self, key, kwargs[key]) 
2030                  del kwargs[key] 
2031          # Were any unrecognized kwargs passed in? 
2032          if __debug__: 
2033              self._complainaboutunusedargs(ss_pb_read_req,kwargs) 
2034          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2035          # Make all P fields that haven't already been constructed 
2036   
2037   
2038 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2039          'Writes this packet to the supplied buffer' 
2040          self._bufferstartoffset=buf.getcurrentoffset() 
2041          try: self.__field_hdr 
2042          except: 
2043              self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_READ }) 
2044          self.__field_hdr.writetobuffer(buf) 
2045          try: self.__field__gen_p_samsungschu750_276 
2046          except: 
2047              self.__field__gen_p_samsungschu750_276=DONTCARE(**{'sizeinbytes': 1}) 
2048          self.__field__gen_p_samsungschu750_276.writetobuffer(buf) 
2049          self.__field_index.writetobuffer(buf) 
2050          self._bufferendoffset=buf.getcurrentoffset() 
2051          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2052   
2053   
2054 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2055          'Reads this packet from the supplied buffer' 
2056          self._bufferstartoffset=buf.getcurrentoffset() 
2057          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2058          self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_READ }) 
2059          self.__field_hdr.readfrombuffer(buf) 
2060          self.__field__gen_p_samsungschu750_276=DONTCARE(**{'sizeinbytes': 1}) 
2061          self.__field__gen_p_samsungschu750_276.readfrombuffer(buf) 
2062          self.__field_index=UINT(**{'sizeinbytes': 2}) 
2063          self.__field_index.readfrombuffer(buf) 
2064          self._bufferendoffset=buf.getcurrentoffset() 
2065   
2066   
2067 -    def __getfield_hdr(self): 
2068          try: self.__field_hdr 
2069          except: 
2070              self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_READ }) 
2071          return self.__field_hdr.getvalue() 
2072   
2073 -    def __setfield_hdr(self, value): 
2074          if isinstance(value,ss_cmd_hdr): 
2075              self.__field_hdr=value 
2076          else: 
2077              self.__field_hdr=ss_cmd_hdr(value,**{ 'command': SS_CMD_PB_READ }) 
2078   
2079 -    def __delfield_hdr(self): del self.__field_hdr 
2080   
2081      hdr=property(__getfield_hdr, __setfield_hdr, __delfield_hdr, None) 
2082   
2083 -    def __getfield_index(self): 
2084          return self.__field_index.getvalue() 
2085   
2086 -    def __setfield_index(self, value): 
2087          if isinstance(value,UINT): 
2088              self.__field_index=value 
2089          else: 
2090              self.__field_index=UINT(value,**{'sizeinbytes': 2}) 
2091   
2092 -    def __delfield_index(self): del self.__field_index 
2093   
2094      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
2095   
2096 -    def iscontainer(self): 
2097          return True 
2098   
2099 -    def containerelements(self): 
2100          yield ('hdr', self.__field_hdr, None) 
2101          yield ('index', self.__field_index, None) 
2102   
2103   
2104   
2105   
2106 -class ss_pb_read_resp(BaseProtogenClass): 
2107      # Read-From-Buffer-Only Class 
2108      __fields=['hdr', 'index', 'data'] 
2109   
2110 -    def __init__(self, *args, **kwargs): 
2111          dict={} 
2112          # What was supplied to this function 
2113          dict.update(kwargs) 
2114          # Parent constructor 
2115          super(ss_pb_read_resp,self).__init__(**dict) 
2116          if self.__class__ is ss_pb_read_resp: 
2117              self._update(args,dict) 
2118   
2119   
2120 -    def getfields(self): 
2121          return self.__fields 
2122   
2123   
2124 -    def _update(self, args, kwargs): 
2125          super(ss_pb_read_resp,self)._update(args,kwargs) 
2126          keys=kwargs.keys() 
2127          for key in keys: 
2128              if key in self.__fields: 
2129                  setattr(self, key, kwargs[key]) 
2130                  del kwargs[key] 
2131          # Were any unrecognized kwargs passed in? 
2132          if __debug__: 
2133              self._complainaboutunusedargs(ss_pb_read_resp,kwargs) 
2134          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2135          # Make all P fields that haven't already been constructed 
2136   
2137   
2138 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2139          'Writes this packet to the supplied buffer' 
2140          raise NotImplementedError 
2141   
2142   
2143 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2144          'Reads this packet from the supplied buffer' 
2145          self._bufferstartoffset=buf.getcurrentoffset() 
2146          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2147          self.__field_hdr=ss_cmd_hdr() 
2148          self.__field_hdr.readfrombuffer(buf) 
2149          DONTCARE(**{'sizeinbytes': 1}).readfrombuffer(buf) 
2150          self.__field_index=UINT(**{'sizeinbytes': 2}) 
2151          self.__field_index.readfrombuffer(buf) 
2152          DONTCARE(**{'sizeinbytes': 1}).readfrombuffer(buf) 
2153          self.__field_data=DATA() 
2154          self.__field_data.readfrombuffer(buf) 
2155          self._bufferendoffset=buf.getcurrentoffset() 
2156   
2157   
2158 -    def __getfield_hdr(self): 
2159          return self.__field_hdr.getvalue() 
2160   
2161 -    def __setfield_hdr(self, value): 
2162          if isinstance(value,ss_cmd_hdr): 
2163              self.__field_hdr=value 
2164          else: 
2165              self.__field_hdr=ss_cmd_hdr(value,) 
2166   
2167 -    def __delfield_hdr(self): del self.__field_hdr 
2168   
2169      hdr=property(__getfield_hdr, __setfield_hdr, __delfield_hdr, None) 
2170   
2171 -    def __getfield_index(self): 
2172          return self.__field_index.getvalue() 
2173   
2174 -    def __setfield_index(self, value): 
2175          if isinstance(value,UINT): 
2176              self.__field_index=value 
2177          else: 
2178              self.__field_index=UINT(value,**{'sizeinbytes': 2}) 
2179   
2180 -    def __delfield_index(self): del self.__field_index 
2181   
2182      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
2183   
2184 -    def __getfield_data(self): 
2185          return self.__field_data.getvalue() 
2186   
2187 -    def __setfield_data(self, value): 
2188          if isinstance(value,DATA): 
2189              self.__field_data=value 
2190          else: 
2191              self.__field_data=DATA(value,) 
2192   
2193 -    def __delfield_data(self): del self.__field_data 
2194   
2195      data=property(__getfield_data, __setfield_data, __delfield_data, None) 
2196   
2197 -    def iscontainer(self): 
2198          return True 
2199   
2200 -    def containerelements(self): 
2201          yield ('hdr', self.__field_hdr, None) 
2202          yield ('index', self.__field_index, None) 
2203          yield ('data', self.__field_data, None) 
2204   
2205   
2206   
2207   
2208 -class ss_pb_voicemail_read_req(BaseProtogenClass): 
2209      __fields=['hdr', 'param'] 
2210   
2211 -    def __init__(self, *args, **kwargs): 
2212          dict={} 
2213          # What was supplied to this function 
2214          dict.update(kwargs) 
2215          # Parent constructor 
2216          super(ss_pb_voicemail_read_req,self).__init__(**dict) 
2217          if self.__class__ is ss_pb_voicemail_read_req: 
2218              self._update(args,dict) 
2219   
2220   
2221 -    def getfields(self): 
2222          return self.__fields 
2223   
2224   
2225 -    def _update(self, args, kwargs): 
2226          super(ss_pb_voicemail_read_req,self)._update(args,kwargs) 
2227          keys=kwargs.keys() 
2228          for key in keys: 
2229              if key in self.__fields: 
2230                  setattr(self, key, kwargs[key]) 
2231                  del kwargs[key] 
2232          # Were any unrecognized kwargs passed in? 
2233          if __debug__: 
2234              self._complainaboutunusedargs(ss_pb_voicemail_read_req,kwargs) 
2235          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2236          # Make all P fields that haven't already been constructed 
2237   
2238   
2239 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2240          'Writes this packet to the supplied buffer' 
2241          self._bufferstartoffset=buf.getcurrentoffset() 
2242          try: self.__field_hdr 
2243          except: 
2244              self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_VOICEMAIL_READ }) 
2245          self.__field_hdr.writetobuffer(buf) 
2246          try: self.__field_param 
2247          except: 
2248              self.__field_param=UINT(**{'sizeinbytes': 1,  'constant': SS_CMD_PB_VOICEMAIL_PARAM }) 
2249          self.__field_param.writetobuffer(buf) 
2250          self._bufferendoffset=buf.getcurrentoffset() 
2251          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2252   
2253   
2254 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2255          'Reads this packet from the supplied buffer' 
2256          self._bufferstartoffset=buf.getcurrentoffset() 
2257          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2258          self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_VOICEMAIL_READ }) 
2259          self.__field_hdr.readfrombuffer(buf) 
2260          self.__field_param=UINT(**{'sizeinbytes': 1,  'constant': SS_CMD_PB_VOICEMAIL_PARAM }) 
2261          self.__field_param.readfrombuffer(buf) 
2262          self._bufferendoffset=buf.getcurrentoffset() 
2263   
2264   
2265 -    def __getfield_hdr(self): 
2266          try: self.__field_hdr 
2267          except: 
2268              self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_VOICEMAIL_READ }) 
2269          return self.__field_hdr.getvalue() 
2270   
2271 -    def __setfield_hdr(self, value): 
2272          if isinstance(value,ss_cmd_hdr): 
2273              self.__field_hdr=value 
2274          else: 
2275              self.__field_hdr=ss_cmd_hdr(value,**{ 'command': SS_CMD_PB_VOICEMAIL_READ }) 
2276   
2277 -    def __delfield_hdr(self): del self.__field_hdr 
2278   
2279      hdr=property(__getfield_hdr, __setfield_hdr, __delfield_hdr, None) 
2280   
2281 -    def __getfield_param(self): 
2282          try: self.__field_param 
2283          except: 
2284              self.__field_param=UINT(**{'sizeinbytes': 1,  'constant': SS_CMD_PB_VOICEMAIL_PARAM }) 
2285          return self.__field_param.getvalue() 
2286   
2287 -    def __setfield_param(self, value): 
2288          if isinstance(value,UINT): 
2289              self.__field_param=value 
2290          else: 
2291              self.__field_param=UINT(value,**{'sizeinbytes': 1,  'constant': SS_CMD_PB_VOICEMAIL_PARAM }) 
2292   
2293 -    def __delfield_param(self): del self.__field_param 
2294   
2295      param=property(__getfield_param, __setfield_param, __delfield_param, None) 
2296   
2297 -    def iscontainer(self): 
2298          return True 
2299   
2300 -    def containerelements(self): 
2301          yield ('hdr', self.__field_hdr, None) 
2302          yield ('param', self.__field_param, None) 
2303   
2304   
2305   
2306   
2307 -class ss_pb_voicemail_resp(BaseProtogenClass): 
2308      # Read-From-Buffer-Only Class 
2309      __fields=['hdr', 'param', 'number'] 
2310   
2311 -    def __init__(self, *args, **kwargs): 
2312          dict={} 
2313          # What was supplied to this function 
2314          dict.update(kwargs) 
2315          # Parent constructor 
2316          super(ss_pb_voicemail_resp,self).__init__(**dict) 
2317          if self.__class__ is ss_pb_voicemail_resp: 
2318              self._update(args,dict) 
2319   
2320   
2321 -    def getfields(self): 
2322          return self.__fields 
2323   
2324   
2325 -    def _update(self, args, kwargs): 
2326          super(ss_pb_voicemail_resp,self)._update(args,kwargs) 
2327          keys=kwargs.keys() 
2328          for key in keys: 
2329              if key in self.__fields: 
2330                  setattr(self, key, kwargs[key]) 
2331                  del kwargs[key] 
2332          # Were any unrecognized kwargs passed in? 
2333          if __debug__: 
2334              self._complainaboutunusedargs(ss_pb_voicemail_resp,kwargs) 
2335          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2336          # Make all P fields that haven't already been constructed 
2337   
2338   
2339 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2340          'Writes this packet to the supplied buffer' 
2341          raise NotImplementedError 
2342   
2343   
2344 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2345          'Reads this packet from the supplied buffer' 
2346          self._bufferstartoffset=buf.getcurrentoffset() 
2347          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2348          self.__field_hdr=ss_cmd_hdr() 
2349          self.__field_hdr.readfrombuffer(buf) 
2350          self.__field_param=UINT(**{'sizeinbytes': 1}) 
2351          self.__field_param.readfrombuffer(buf) 
2352          self.__field_number=STRING(**{ 'terminator': 0 }) 
2353          self.__field_number.readfrombuffer(buf) 
2354          self._bufferendoffset=buf.getcurrentoffset() 
2355   
2356   
2357 -    def __getfield_hdr(self): 
2358          return self.__field_hdr.getvalue() 
2359   
2360 -    def __setfield_hdr(self, value): 
2361          if isinstance(value,ss_cmd_hdr): 
2362              self.__field_hdr=value 
2363          else: 
2364              self.__field_hdr=ss_cmd_hdr(value,) 
2365   
2366 -    def __delfield_hdr(self): del self.__field_hdr 
2367   
2368      hdr=property(__getfield_hdr, __setfield_hdr, __delfield_hdr, None) 
2369   
2370 -    def __getfield_param(self): 
2371          return self.__field_param.getvalue() 
2372   
2373 -    def __setfield_param(self, value): 
2374          if isinstance(value,UINT): 
2375              self.__field_param=value 
2376          else: 
2377              self.__field_param=UINT(value,**{'sizeinbytes': 1}) 
2378   
2379 -    def __delfield_param(self): del self.__field_param 
2380   
2381      param=property(__getfield_param, __setfield_param, __delfield_param, None) 
2382   
2383 -    def __getfield_number(self): 
2384          return self.__field_number.getvalue() 
2385   
2386 -    def __setfield_number(self, value): 
2387          if isinstance(value,STRING): 
2388              self.__field_number=value 
2389          else: 
2390              self.__field_number=STRING(value,**{ 'terminator': 0 }) 
2391   
2392 -    def __delfield_number(self): del self.__field_number 
2393   
2394      number=property(__getfield_number, __setfield_number, __delfield_number, None) 
2395   
2396 -    def iscontainer(self): 
2397          return True 
2398   
2399 -    def containerelements(self): 
2400          yield ('hdr', self.__field_hdr, None) 
2401          yield ('param', self.__field_param, None) 
2402          yield ('number', self.__field_number, None) 
2403   
2404   
2405   
2406   
2407 -class ss_pb_voicemail_write_req(BaseProtogenClass): 
2408      __fields=['hdr', 'param', 'number'] 
2409   
2410 -    def __init__(self, *args, **kwargs): 
2411          dict={} 
2412          # What was supplied to this function 
2413          dict.update(kwargs) 
2414          # Parent constructor 
2415          super(ss_pb_voicemail_write_req,self).__init__(**dict) 
2416          if self.__class__ is ss_pb_voicemail_write_req: 
2417              self._update(args,dict) 
2418   
2419   
2420 -    def getfields(self): 
2421          return self.__fields 
2422   
2423   
2424 -    def _update(self, args, kwargs): 
2425          super(ss_pb_voicemail_write_req,self)._update(args,kwargs) 
2426          keys=kwargs.keys() 
2427          for key in keys: 
2428              if key in self.__fields: 
2429                  setattr(self, key, kwargs[key]) 
2430                  del kwargs[key] 
2431          # Were any unrecognized kwargs passed in? 
2432          if __debug__: 
2433              self._complainaboutunusedargs(ss_pb_voicemail_write_req,kwargs) 
2434          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2435          # Make all P fields that haven't already been constructed 
2436   
2437   
2438 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2439          'Writes this packet to the supplied buffer' 
2440          self._bufferstartoffset=buf.getcurrentoffset() 
2441          try: self.__field_hdr 
2442          except: 
2443              self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_VOICEMAIL_WRITE }) 
2444          self.__field_hdr.writetobuffer(buf) 
2445          try: self.__field_param 
2446          except: 
2447              self.__field_param=UINT(**{'sizeinbytes': 1,  'constant': SS_CMD_PB_VOICEMAIL_PARAM }) 
2448          self.__field_param.writetobuffer(buf) 
2449          try: self.__field_number 
2450          except: 
2451              self.__field_number=STRING(**{ 'terminator': 0,               'default': PB_DEFAULT_VOICEMAIL_NUMBER }) 
2452          self.__field_number.writetobuffer(buf) 
2453          self._bufferendoffset=buf.getcurrentoffset() 
2454          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2455   
2456   
2457 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2458          'Reads this packet from the supplied buffer' 
2459          self._bufferstartoffset=buf.getcurrentoffset() 
2460          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2461          self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_VOICEMAIL_WRITE }) 
2462          self.__field_hdr.readfrombuffer(buf) 
2463          self.__field_param=UINT(**{'sizeinbytes': 1,  'constant': SS_CMD_PB_VOICEMAIL_PARAM }) 
2464          self.__field_param.readfrombuffer(buf) 
2465          self.__field_number=STRING(**{ 'terminator': 0,               'default': PB_DEFAULT_VOICEMAIL_NUMBER }) 
2466          self.__field_number.readfrombuffer(buf) 
2467          self._bufferendoffset=buf.getcurrentoffset() 
2468   
2469   
2470 -    def __getfield_hdr(self): 
2471          try: self.__field_hdr 
2472          except: 
2473              self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_VOICEMAIL_WRITE }) 
2474          return self.__field_hdr.getvalue() 
2475   
2476 -    def __setfield_hdr(self, value): 
2477          if isinstance(value,ss_cmd_hdr): 
2478              self.__field_hdr=value 
2479          else: 
2480              self.__field_hdr=ss_cmd_hdr(value,**{ 'command': SS_CMD_PB_VOICEMAIL_WRITE }) 
2481   
2482 -    def __delfield_hdr(self): del self.__field_hdr 
2483   
2484      hdr=property(__getfield_hdr, __setfield_hdr, __delfield_hdr, None) 
2485   
2486 -    def __getfield_param(self): 
2487          try: self.__field_param 
2488          except: 
2489              self.__field_param=UINT(**{'sizeinbytes': 1,  'constant': SS_CMD_PB_VOICEMAIL_PARAM }) 
2490          return self.__field_param.getvalue() 
2491   
2492 -    def __setfield_param(self, value): 
2493          if isinstance(value,UINT): 
2494              self.__field_param=value 
2495          else: 
2496              self.__field_param=UINT(value,**{'sizeinbytes': 1,  'constant': SS_CMD_PB_VOICEMAIL_PARAM }) 
2497   
2498 -    def __delfield_param(self): del self.__field_param 
2499   
2500      param=property(__getfield_param, __setfield_param, __delfield_param, None) 
2501   
2502 -    def __getfield_number(self): 
2503          try: self.__field_number 
2504          except: 
2505              self.__field_number=STRING(**{ 'terminator': 0,               'default': PB_DEFAULT_VOICEMAIL_NUMBER }) 
2506          return self.__field_number.getvalue() 
2507   
2508 -    def __setfield_number(self, value): 
2509          if isinstance(value,STRING): 
2510              self.__field_number=value 
2511          else: 
2512              self.__field_number=STRING(value,**{ 'terminator': 0,               'default': PB_DEFAULT_VOICEMAIL_NUMBER }) 
2513   
2514 -    def __delfield_number(self): del self.__field_number 
2515   
2516      number=property(__getfield_number, __setfield_number, __delfield_number, None) 
2517   
2518 -    def iscontainer(self): 
2519          return True 
2520   
2521 -    def containerelements(self): 
2522          yield ('hdr', self.__field_hdr, None) 
2523          yield ('param', self.__field_param, None) 
2524          yield ('number', self.__field_number, None) 
2525   
2526   
2527   
2528   
2529 -class ss_pb_clear_req(BaseProtogenClass): 
2530      __fields=['hdr'] 
2531   
2532 -    def __init__(self, *args, **kwargs): 
2533          dict={} 
2534          # What was supplied to this function 
2535          dict.update(kwargs) 
2536          # Parent constructor 
2537          super(ss_pb_clear_req,self).__init__(**dict) 
2538          if self.__class__ is ss_pb_clear_req: 
2539              self._update(args,dict) 
2540   
2541   
2542 -    def getfields(self): 
2543          return self.__fields 
2544   
2545   
2546 -    def _update(self, args, kwargs): 
2547          super(ss_pb_clear_req,self)._update(args,kwargs) 
2548          keys=kwargs.keys() 
2549          for key in keys: 
2550              if key in self.__fields: 
2551                  setattr(self, key, kwargs[key]) 
2552                  del kwargs[key] 
2553          # Were any unrecognized kwargs passed in? 
2554          if __debug__: 
2555              self._complainaboutunusedargs(ss_pb_clear_req,kwargs) 
2556          if len(args): 
2557              dict2={ 'command': SS_CMD_PB_CLEAR } 
2558              dict2.update(kwargs) 
2559              kwargs=dict2 
2560              self.__field_hdr=ss_cmd_hdr(*args,**dict2) 
2561          # Make all P fields that haven't already been constructed 
2562   
2563   
2564 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2565          'Writes this packet to the supplied buffer' 
2566          self._bufferstartoffset=buf.getcurrentoffset() 
2567          try: self.__field_hdr 
2568          except: 
2569              self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_CLEAR }) 
2570          self.__field_hdr.writetobuffer(buf) 
2571          self._bufferendoffset=buf.getcurrentoffset() 
2572          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2573   
2574   
2575 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2576          'Reads this packet from the supplied buffer' 
2577          self._bufferstartoffset=buf.getcurrentoffset() 
2578          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2579          self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_CLEAR }) 
2580          self.__field_hdr.readfrombuffer(buf) 
2581          self._bufferendoffset=buf.getcurrentoffset() 
2582   
2583   
2584 -    def __getfield_hdr(self): 
2585          try: self.__field_hdr 
2586          except: 
2587              self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_CLEAR }) 
2588          return self.__field_hdr.getvalue() 
2589   
2590 -    def __setfield_hdr(self, value): 
2591          if isinstance(value,ss_cmd_hdr): 
2592              self.__field_hdr=value 
2593          else: 
2594              self.__field_hdr=ss_cmd_hdr(value,**{ 'command': SS_CMD_PB_CLEAR }) 
2595   
2596 -    def __delfield_hdr(self): del self.__field_hdr 
2597   
2598      hdr=property(__getfield_hdr, __setfield_hdr, __delfield_hdr, None) 
2599   
2600 -    def iscontainer(self): 
2601          return True 
2602   
2603 -    def containerelements(self): 
2604          yield ('hdr', self.__field_hdr, None) 
2605   
2606   
2607   
2608   
2609 -class ss_pb_clear_resp(BaseProtogenClass): 
2610      # Read-From-Buffer-Only Class 
2611      __fields=['hdr', 'flg'] 
2612   
2613 -    def __init__(self, *args, **kwargs): 
2614          dict={} 
2615          # What was supplied to this function 
2616          dict.update(kwargs) 
2617          # Parent constructor 
2618          super(ss_pb_clear_resp,self).__init__(**dict) 
2619          if self.__class__ is ss_pb_clear_resp: 
2620              self._update(args,dict) 
2621   
2622   
2623 -    def getfields(self): 
2624          return self.__fields 
2625   
2626   
2627 -    def _update(self, args, kwargs): 
2628          super(ss_pb_clear_resp,self)._update(args,kwargs) 
2629          keys=kwargs.keys() 
2630          for key in keys: 
2631              if key in self.__fields: 
2632                  setattr(self, key, kwargs[key]) 
2633                  del kwargs[key] 
2634          # Were any unrecognized kwargs passed in? 
2635          if __debug__: 
2636              self._complainaboutunusedargs(ss_pb_clear_resp,kwargs) 
2637          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2638          # Make all P fields that haven't already been constructed 
2639   
2640   
2641 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2642          'Writes this packet to the supplied buffer' 
2643          raise NotImplementedError 
2644   
2645   
2646 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2647          'Reads this packet from the supplied buffer' 
2648          self._bufferstartoffset=buf.getcurrentoffset() 
2649          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2650          self.__field_hdr=ss_cmd_hdr() 
2651          self.__field_hdr.readfrombuffer(buf) 
2652          self.__field_flg=UINT(**{'sizeinbytes': 2}) 
2653          self.__field_flg.readfrombuffer(buf) 
2654          self._bufferendoffset=buf.getcurrentoffset() 
2655   
2656   
2657 -    def __getfield_hdr(self): 
2658          return self.__field_hdr.getvalue() 
2659   
2660 -    def __setfield_hdr(self, value): 
2661          if isinstance(value,ss_cmd_hdr): 
2662              self.__field_hdr=value 
2663          else: 
2664              self.__field_hdr=ss_cmd_hdr(value,) 
2665   
2666 -    def __delfield_hdr(self): del self.__field_hdr 
2667   
2668      hdr=property(__getfield_hdr, __setfield_hdr, __delfield_hdr, None) 
2669   
2670 -    def __getfield_flg(self): 
2671          return self.__field_flg.getvalue() 
2672   
2673 -    def __setfield_flg(self, value): 
2674          if isinstance(value,UINT): 
2675              self.__field_flg=value 
2676          else: 
2677              self.__field_flg=UINT(value,**{'sizeinbytes': 2}) 
2678   
2679 -    def __delfield_flg(self): del self.__field_flg 
2680   
2681      flg=property(__getfield_flg, __setfield_flg, __delfield_flg, None) 
2682   
2683 -    def iscontainer(self): 
2684          return True 
2685   
2686 -    def containerelements(self): 
2687          yield ('hdr', self.__field_hdr, None) 
2688          yield ('flg', self.__field_flg, None) 
2689   
2690   
2691   
2692   
2693 -class ss_number_entry(BaseProtogenClass): 
2694      __fields=['number', 'speeddial', 'primary', 'ringtone'] 
2695   
2696 -    def __init__(self, *args, **kwargs): 
2697          dict={} 
2698          # What was supplied to this function 
2699          dict.update(kwargs) 
2700          # Parent constructor 
2701          super(ss_number_entry,self).__init__(**dict) 
2702          if self.__class__ is ss_number_entry: 
2703              self._update(args,dict) 
2704   
2705   
2706 -    def getfields(self): 
2707          return self.__fields 
2708   
2709   
2710 -    def _update(self, args, kwargs): 
2711          super(ss_number_entry,self)._update(args,kwargs) 
2712          keys=kwargs.keys() 
2713          for key in keys: 
2714              if key in self.__fields: 
2715                  setattr(self, key, kwargs[key]) 
2716                  del kwargs[key] 
2717          # Were any unrecognized kwargs passed in? 
2718          if __debug__: 
2719              self._complainaboutunusedargs(ss_number_entry,kwargs) 
2720          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2721          # Make all P fields that haven't already been constructed 
2722   
2723   
2724 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2725          'Writes this packet to the supplied buffer' 
2726          self._bufferstartoffset=buf.getcurrentoffset() 
2727          try: self.__field_number 
2728          except: 
2729              self.__field_number=STRING(**{ 'terminator': 0,               'default': '',               'maxsizeinbytes': PB_MAX_NUMBER_LEN,               'raiseontruncate': False }) 
2730          self.__field_number.writetobuffer(buf) 
2731          try: self.__field_speeddial 
2732          except: 
2733              self.__field_speeddial=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
2734          self.__field_speeddial.writetobuffer(buf) 
2735          try: self.__field_primary 
2736          except: 
2737              self.__field_primary=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
2738          self.__field_primary.writetobuffer(buf) 
2739          try: self.__field__gen_p_samsungschu750_309 
2740          except: 
2741              self.__field__gen_p_samsungschu750_309=DONTCARE(**{'sizeinbytes': 8}) 
2742          self.__field__gen_p_samsungschu750_309.writetobuffer(buf) 
2743          try: self.__field_ringtone 
2744          except: 
2745              self.__field_ringtone=STRING(**{ 'terminator': 0,               'default': '' }) 
2746          self.__field_ringtone.writetobuffer(buf) 
2747          self._bufferendoffset=buf.getcurrentoffset() 
2748          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2749   
2750   
2751 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2752          'Reads this packet from the supplied buffer' 
2753          self._bufferstartoffset=buf.getcurrentoffset() 
2754          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2755          self.__field_number=STRING(**{ 'terminator': 0,               'default': '',               'maxsizeinbytes': PB_MAX_NUMBER_LEN,               'raiseontruncate': False }) 
2756          self.__field_number.readfrombuffer(buf) 
2757          self.__field_speeddial=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
2758          self.__field_speeddial.readfrombuffer(buf) 
2759          self.__field_primary=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
2760          self.__field_primary.readfrombuffer(buf) 
2761          self.__field__gen_p_samsungschu750_309=DONTCARE(**{'sizeinbytes': 8}) 
2762          self.__field__gen_p_samsungschu750_309.readfrombuffer(buf) 
2763          self.__field_ringtone=STRING(**{ 'terminator': 0,               'default': '' }) 
2764          self.__field_ringtone.readfrombuffer(buf) 
2765          self._bufferendoffset=buf.getcurrentoffset() 
2766   
2767   
2768 -    def __getfield_number(self): 
2769          try: self.__field_number 
2770          except: 
2771              self.__field_number=STRING(**{ 'terminator': 0,               'default': '',               'maxsizeinbytes': PB_MAX_NUMBER_LEN,               'raiseontruncate': False }) 
2772          return self.__field_number.getvalue() 
2773   
2774 -    def __setfield_number(self, value): 
2775          if isinstance(value,STRING): 
2776              self.__field_number=value 
2777          else: 
2778              self.__field_number=STRING(value,**{ 'terminator': 0,               'default': '',               'maxsizeinbytes': PB_MAX_NUMBER_LEN,               'raiseontruncate': False }) 
2779   
2780 -    def __delfield_number(self): del self.__field_number 
2781   
2782      number=property(__getfield_number, __setfield_number, __delfield_number, None) 
2783   
2784 -    def __getfield_speeddial(self): 
2785          try: self.__field_speeddial 
2786          except: 
2787              self.__field_speeddial=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
2788          return self.__field_speeddial.getvalue() 
2789   
2790 -    def __setfield_speeddial(self, value): 
2791          if isinstance(value,UINT): 
2792              self.__field_speeddial=value 
2793          else: 
2794              self.__field_speeddial=UINT(value,**{'sizeinbytes': 2,  'default': 0 }) 
2795   
2796 -    def __delfield_speeddial(self): del self.__field_speeddial 
2797   
2798      speeddial=property(__getfield_speeddial, __setfield_speeddial, __delfield_speeddial, None) 
2799   
2800 -    def __getfield_primary(self): 
2801          try: self.__field_primary 
2802          except: 
2803              self.__field_primary=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
2804          return self.__field_primary.getvalue() 
2805   
2806 -    def __setfield_primary(self, value): 
2807          if isinstance(value,UINT): 
2808              self.__field_primary=value 
2809          else: 
2810              self.__field_primary=UINT(value,**{'sizeinbytes': 1,  'default': 0 }) 
2811   
2812 -    def __delfield_primary(self): del self.__field_primary 
2813   
2814      primary=property(__getfield_primary, __setfield_primary, __delfield_primary, None) 
2815   
2816 -    def __getfield_ringtone(self): 
2817          try: self.__field_ringtone 
2818          except: 
2819              self.__field_ringtone=STRING(**{ 'terminator': 0,               'default': '' }) 
2820          return self.__field_ringtone.getvalue() 
2821   
2822 -    def __setfield_ringtone(self, value): 
2823          if isinstance(value,STRING): 
2824              self.__field_ringtone=value 
2825          else: 
2826              self.__field_ringtone=STRING(value,**{ 'terminator': 0,               'default': '' }) 
2827   
2828 -    def __delfield_ringtone(self): del self.__field_ringtone 
2829   
2830      ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 
2831   
2832 -    def iscontainer(self): 
2833          return True 
2834   
2835 -    def containerelements(self): 
2836          yield ('number', self.__field_number, None) 
2837          yield ('speeddial', self.__field_speeddial, None) 
2838          yield ('primary', self.__field_primary, None) 
2839          yield ('ringtone', self.__field_ringtone, None) 
2840   
2841   
2842   
2843   
2844 -class ss_pb_entry(BaseProtogenClass): 
2845      __fields=['name', 'email', 'email2', 'note', 'wallpaper', 'wallpaper_range', 'home', 'work', 'cell', 'dummy', 'fax', 'cell2', 'group', 'street', 'city', 'state', 'zipcode', 'country', 'im_name', 'im_type'] 
2846   
2847 -    def __init__(self, *args, **kwargs): 
2848          dict={} 
2849          # What was supplied to this function 
2850          dict.update(kwargs) 
2851          # Parent constructor 
2852          super(ss_pb_entry,self).__init__(**dict) 
2853          if self.__class__ is ss_pb_entry: 
2854              self._update(args,dict) 
2855   
2856   
2857 -    def getfields(self): 
2858          return self.__fields 
2859   
2860   
2861 -    def _update(self, args, kwargs): 
2862          super(ss_pb_entry,self)._update(args,kwargs) 
2863          keys=kwargs.keys() 
2864          for key in keys: 
2865              if key in self.__fields: 
2866                  setattr(self, key, kwargs[key]) 
2867                  del kwargs[key] 
2868          # Were any unrecognized kwargs passed in? 
2869          if __debug__: 
2870              self._complainaboutunusedargs(ss_pb_entry,kwargs) 
2871          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2872          # Make all P fields that haven't already been constructed 
2873   
2874   
2875 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2876          'Writes this packet to the supplied buffer' 
2877          self._bufferstartoffset=buf.getcurrentoffset() 
2878          self.__field_name.writetobuffer(buf) 
2879          try: self.__field_email 
2880          except: 
2881              self.__field_email=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'default': '',                'maxsizeinbytes': PB_MAX_EMAIL_LEN,                'raiseontruncate': False }) 
2882          self.__field_email.writetobuffer(buf) 
2883          try: self.__field_email2 
2884          except: 
2885              self.__field_email2=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'default': '',                'maxsizeinbytes': PB_MAX_EMAIL_LEN,                'raiseontruncate': False }) 
2886          self.__field_email2.writetobuffer(buf) 
2887          try: self.__field__gen_p_samsungschu750_328 
2888          except: 
2889              self.__field__gen_p_samsungschu750_328=DONTCARE(**{'sizeinbytes': 2}) 
2890          self.__field__gen_p_samsungschu750_328.writetobuffer(buf) 
2891          try: self.__field_note 
2892          except: 
2893              self.__field_note=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'maxsizeinbytes': PB_MAX_NOTE_LEN,                'raiseontruncate': False,                'default': '' }) 
2894          self.__field_note.writetobuffer(buf) 
2895          try: self.__field__gen_p_samsungschu750_334 
2896          except: 
2897              self.__field__gen_p_samsungschu750_334=DONTCARE(**{'sizeinbytes': 1}) 
2898          self.__field__gen_p_samsungschu750_334.writetobuffer(buf) 
2899          try: self.__field_wallpaper 
2900          except: 
2901              self.__field_wallpaper=STRING(**{ 'terminator': 0,               'default': '' }) 
2902          self.__field_wallpaper.writetobuffer(buf) 
2903          try: self.__field_wallpaper_range 
2904          except: 
2905              self.__field_wallpaper_range=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
2906          self.__field_wallpaper_range.writetobuffer(buf) 
2907          try: self.__field_home 
2908          except: 
2909              self.__field_home=ss_number_entry() 
2910          self.__field_home.writetobuffer(buf) 
2911          try: self.__field_work 
2912          except: 
2913              self.__field_work=ss_number_entry() 
2914          self.__field_work.writetobuffer(buf) 
2915          try: self.__field_cell 
2916          except: 
2917              self.__field_cell=ss_number_entry() 
2918          self.__field_cell.writetobuffer(buf) 
2919          try: self.__field_dummy 
2920          except: 
2921              self.__field_dummy=ss_number_entry() 
2922          self.__field_dummy.writetobuffer(buf) 
2923          try: self.__field_fax 
2924          except: 
2925              self.__field_fax=ss_number_entry() 
2926          self.__field_fax.writetobuffer(buf) 
2927          try: self.__field_cell2 
2928          except: 
2929              self.__field_cell2=ss_number_entry() 
2930          self.__field_cell2.writetobuffer(buf) 
2931          try: self.__field__gen_p_samsungschu750_344 
2932          except: 
2933              self.__field__gen_p_samsungschu750_344=DONTCARE(**{'sizeinbytes': 4}) 
2934          self.__field__gen_p_samsungschu750_344.writetobuffer(buf) 
2935          try: self.__field_group 
2936          except: 
2937              self.__field_group=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
2938          self.__field_group.writetobuffer(buf) 
2939          try: self.__field__gen_p_samsungschu750_346 
2940          except: 
2941              self.__field__gen_p_samsungschu750_346=DONTCARE(**{'sizeinbytes': 2}) 
2942          self.__field__gen_p_samsungschu750_346.writetobuffer(buf) 
2943          try: self.__field_street 
2944          except: 
2945              self.__field_street=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'maxsizeinbytes': PB_MAX_STREET_LEN,                'raiseontruncate': False,                'default': '' }) 
2946          self.__field_street.writetobuffer(buf) 
2947          try: self.__field_city 
2948          except: 
2949              self.__field_city=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'maxsizeinbytes': PB_MAX_CITY_LEN,                'raiseontruncate': False,                'default': '' }) 
2950          self.__field_city.writetobuffer(buf) 
2951          try: self.__field_state 
2952          except: 
2953              self.__field_state=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'maxsizeinbytes': PB_MAX_STATE_LEN,                'raiseontruncate': False,                'default': '' }) 
2954          self.__field_state.writetobuffer(buf) 
2955          try: self.__field_zipcode 
2956          except: 
2957              self.__field_zipcode=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'maxsizeinbytes': PB_MAX_ZIP_LEN,                'raiseontruncate': False,                'default': '' }) 
2958          self.__field_zipcode.writetobuffer(buf) 
2959          try: self.__field_country 
2960          except: 
2961              self.__field_country=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'maxsizeinbytes': PB_MAX_COUNTRY_LEN,                'raiseontruncate': False,                'default': '' }) 
2962          self.__field_country.writetobuffer(buf) 
2963          try: self.__field_im_name 
2964          except: 
2965              self.__field_im_name=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'maxsizeinbytes': PB_MAX_IMNAME_LEN,                'raiseontruncate': False,                'default': '' }) 
2966          self.__field_im_name.writetobuffer(buf) 
2967          try: self.__field_im_type 
2968          except: 
2969              self.__field_im_type=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
2970          self.__field_im_type.writetobuffer(buf) 
2971          self._bufferendoffset=buf.getcurrentoffset() 
2972          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2973   
2974   
2975 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2976          'Reads this packet from the supplied buffer' 
2977          self._bufferstartoffset=buf.getcurrentoffset() 
2978          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2979          self.__field_name=USTRING(**{ 'terminator': 0,                'maxsizeinbytes': PB_MAX_NAME_LEN,                'encoding': ENCODING,                'raiseontruncate': False }) 
2980          self.__field_name.readfrombuffer(buf) 
2981          self.__field_email=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'default': '',                'maxsizeinbytes': PB_MAX_EMAIL_LEN,                'raiseontruncate': False }) 
2982          self.__field_email.readfrombuffer(buf) 
2983          self.__field_email2=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'default': '',                'maxsizeinbytes': PB_MAX_EMAIL_LEN,                'raiseontruncate': False }) 
2984          self.__field_email2.readfrombuffer(buf) 
2985          self.__field__gen_p_samsungschu750_328=DONTCARE(**{'sizeinbytes': 2}) 
2986          self.__field__gen_p_samsungschu750_328.readfrombuffer(buf) 
2987          self.__field_note=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'maxsizeinbytes': PB_MAX_NOTE_LEN,                'raiseontruncate': False,                'default': '' }) 
2988          self.__field_note.readfrombuffer(buf) 
2989          self.__field__gen_p_samsungschu750_334=DONTCARE(**{'sizeinbytes': 1}) 
2990          self.__field__gen_p_samsungschu750_334.readfrombuffer(buf) 
2991          self.__field_wallpaper=STRING(**{ 'terminator': 0,               'default': '' }) 
2992          self.__field_wallpaper.readfrombuffer(buf) 
2993          self.__field_wallpaper_range=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
2994          self.__field_wallpaper_range.readfrombuffer(buf) 
2995          self.__field_home=ss_number_entry() 
2996          self.__field_home.readfrombuffer(buf) 
2997          self.__field_work=ss_number_entry() 
2998          self.__field_work.readfrombuffer(buf) 
2999          self.__field_cell=ss_number_entry() 
3000          self.__field_cell.readfrombuffer(buf) 
3001          self.__field_dummy=ss_number_entry() 
3002          self.__field_dummy.readfrombuffer(buf) 
3003          self.__field_fax=ss_number_entry() 
3004          self.__field_fax.readfrombuffer(buf) 
3005          self.__field_cell2=ss_number_entry() 
3006          self.__field_cell2.readfrombuffer(buf) 
3007          self.__field__gen_p_samsungschu750_344=DONTCARE(**{'sizeinbytes': 4}) 
3008          self.__field__gen_p_samsungschu750_344.readfrombuffer(buf) 
3009          self.__field_group=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
3010          self.__field_group.readfrombuffer(buf) 
3011          self.__field__gen_p_samsungschu750_346=DONTCARE(**{'sizeinbytes': 2}) 
3012          self.__field__gen_p_samsungschu750_346.readfrombuffer(buf) 
3013          self.__field_street=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'maxsizeinbytes': PB_MAX_STREET_LEN,                'raiseontruncate': False,                'default': '' }) 
3014          self.__field_street.readfrombuffer(buf) 
3015          self.__field_city=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'maxsizeinbytes': PB_MAX_CITY_LEN,                'raiseontruncate': False,                'default': '' }) 
3016          self.__field_city.readfrombuffer(buf) 
3017          self.__field_state=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'maxsizeinbytes': PB_MAX_STATE_LEN,                'raiseontruncate': False,                'default': '' }) 
3018          self.__field_state.readfrombuffer(buf) 
3019          self.__field_zipcode=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'maxsizeinbytes': PB_MAX_ZIP_LEN,                'raiseontruncate': False,                'default': '' }) 
3020          self.__field_zipcode.readfrombuffer(buf) 
3021          self.__field_country=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'maxsizeinbytes': PB_MAX_COUNTRY_LEN,                'raiseontruncate': False,                'default': '' }) 
3022          self.__field_country.readfrombuffer(buf) 
3023          self.__field_im_name=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'maxsizeinbytes': PB_MAX_IMNAME_LEN,                'raiseontruncate': False,                'default': '' }) 
3024          self.__field_im_name.readfrombuffer(buf) 
3025          self.__field_im_type=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
3026          self.__field_im_type.readfrombuffer(buf) 
3027          self._bufferendoffset=buf.getcurrentoffset() 
3028   
3029   
3030 -    def __getfield_name(self): 
3031          return self.__field_name.getvalue() 
3032   
3033 -    def __setfield_name(self, value): 
3034          if isinstance(value,USTRING): 
3035              self.__field_name=value 
3036          else: 
3037              self.__field_name=USTRING(value,**{ 'terminator': 0,                'maxsizeinbytes': PB_MAX_NAME_LEN,                'encoding': ENCODING,                'raiseontruncate': False }) 
3038   
3039 -    def __delfield_name(self): del self.__field_name 
3040   
3041      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
3042   
3043 -    def __getfield_email(self): 
3044          try: self.__field_email 
3045          except: 
3046              self.__field_email=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'default': '',                'maxsizeinbytes': PB_MAX_EMAIL_LEN,                'raiseontruncate': False }) 
3047          return self.__field_email.getvalue() 
3048   
3049 -    def __setfield_email(self, value): 
3050          if isinstance(value,USTRING): 
3051              self.__field_email=value 
3052          else: 
3053              self.__field_email=USTRING(value,**{ 'terminator': 0,                'encoding': ENCODING,                'default': '',                'maxsizeinbytes': PB_MAX_EMAIL_LEN,                'raiseontruncate': False }) 
3054   
3055 -    def __delfield_email(self): del self.__field_email 
3056   
3057      email=property(__getfield_email, __setfield_email, __delfield_email, None) 
3058   
3059 -    def __getfield_email2(self): 
3060          try: self.__field_email2 
3061          except: 
3062              self.__field_email2=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'default': '',                'maxsizeinbytes': PB_MAX_EMAIL_LEN,                'raiseontruncate': False }) 
3063          return self.__field_email2.getvalue() 
3064   
3065 -    def __setfield_email2(self, value): 
3066          if isinstance(value,USTRING): 
3067              self.__field_email2=value 
3068          else: 
3069              self.__field_email2=USTRING(value,**{ 'terminator': 0,                'encoding': ENCODING,                'default': '',                'maxsizeinbytes': PB_MAX_EMAIL_LEN,                'raiseontruncate': False }) 
3070   
3071 -    def __delfield_email2(self): del self.__field_email2 
3072   
3073      email2=property(__getfield_email2, __setfield_email2, __delfield_email2, None) 
3074   
3075 -    def __getfield_note(self): 
3076          try: self.__field_note 
3077          except: 
3078              self.__field_note=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'maxsizeinbytes': PB_MAX_NOTE_LEN,                'raiseontruncate': False,                'default': '' }) 
3079          return self.__field_note.getvalue() 
3080   
3081 -    def __setfield_note(self, value): 
3082          if isinstance(value,USTRING): 
3083              self.__field_note=value 
3084          else: 
3085              self.__field_note=USTRING(value,**{ 'terminator': 0,                'encoding': ENCODING,                'maxsizeinbytes': PB_MAX_NOTE_LEN,                'raiseontruncate': False,                'default': '' }) 
3086   
3087 -    def __delfield_note(self): del self.__field_note 
3088   
3089      note=property(__getfield_note, __setfield_note, __delfield_note, None) 
3090   
3091 -    def __getfield_wallpaper(self): 
3092          try: self.__field_wallpaper 
3093          except: 
3094              self.__field_wallpaper=STRING(**{ 'terminator': 0,               'default': '' }) 
3095          return self.__field_wallpaper.getvalue() 
3096   
3097 -    def __setfield_wallpaper(self, value): 
3098          if isinstance(value,STRING): 
3099              self.__field_wallpaper=value 
3100          else: 
3101              self.__field_wallpaper=STRING(value,**{ 'terminator': 0,               'default': '' }) 
3102   
3103 -    def __delfield_wallpaper(self): del self.__field_wallpaper 
3104   
3105      wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None) 
3106   
3107 -    def __getfield_wallpaper_range(self): 
3108          try: self.__field_wallpaper_range 
3109          except: 
3110              self.__field_wallpaper_range=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
3111          return self.__field_wallpaper_range.getvalue() 
3112   
3113 -    def __setfield_wallpaper_range(self, value): 
3114          if isinstance(value,UINT): 
3115              self.__field_wallpaper_range=value 
3116          else: 
3117              self.__field_wallpaper_range=UINT(value,**{'sizeinbytes': 1,  'default': 0 }) 
3118   
3119 -    def __delfield_wallpaper_range(self): del self.__field_wallpaper_range 
3120   
3121      wallpaper_range=property(__getfield_wallpaper_range, __setfield_wallpaper_range, __delfield_wallpaper_range, None) 
3122   
3123 -    def __getfield_home(self): 
3124          try: self.__field_home 
3125          except: 
3126              self.__field_home=ss_number_entry() 
3127          return self.__field_home.getvalue() 
3128   
3129 -    def __setfield_home(self, value): 
3130          if isinstance(value,ss_number_entry): 
3131              self.__field_home=value 
3132          else: 
3133              self.__field_home=ss_number_entry(value,) 
3134   
3135 -    def __delfield_home(self): del self.__field_home 
3136   
3137      home=property(__getfield_home, __setfield_home, __delfield_home, None) 
3138   
3139 -    def __getfield_work(self): 
3140          try: self.__field_work 
3141          except: 
3142              self.__field_work=ss_number_entry() 
3143          return self.__field_work.getvalue() 
3144   
3145 -    def __setfield_work(self, value): 
3146          if isinstance(value,ss_number_entry): 
3147              self.__field_work=value 
3148          else: 
3149              self.__field_work=ss_number_entry(value,) 
3150   
3151 -    def __delfield_work(self): del self.__field_work 
3152   
3153      work=property(__getfield_work, __setfield_work, __delfield_work, None) 
3154   
3155 -    def __getfield_cell(self): 
3156          try: self.__field_cell 
3157          except: 
3158              self.__field_cell=ss_number_entry() 
3159          return self.__field_cell.getvalue() 
3160   
3161 -    def __setfield_cell(self, value): 
3162          if isinstance(value,ss_number_entry): 
3163              self.__field_cell=value 
3164          else: 
3165              self.__field_cell=ss_number_entry(value,) 
3166   
3167 -    def __delfield_cell(self): del self.__field_cell 
3168   
3169      cell=property(__getfield_cell, __setfield_cell, __delfield_cell, None) 
3170   
3171 -    def __getfield_dummy(self): 
3172          try: self.__field_dummy 
3173          except: 
3174              self.__field_dummy=ss_number_entry() 
3175          return self.__field_dummy.getvalue() 
3176   
3177 -    def __setfield_dummy(self, value): 
3178          if isinstance(value,ss_number_entry): 
3179              self.__field_dummy=value 
3180          else: 
3181              self.__field_dummy=ss_number_entry(value,) 
3182   
3183 -    def __delfield_dummy(self): del self.__field_dummy 
3184   
3185      dummy=property(__getfield_dummy, __setfield_dummy, __delfield_dummy, None) 
3186   
3187 -    def __getfield_fax(self): 
3188          try: self.__field_fax 
3189          except: 
3190              self.__field_fax=ss_number_entry() 
3191          return self.__field_fax.getvalue() 
3192   
3193 -    def __setfield_fax(self, value): 
3194          if isinstance(value,ss_number_entry): 
3195              self.__field_fax=value 
3196          else: 
3197              self.__field_fax=ss_number_entry(value,) 
3198   
3199 -    def __delfield_fax(self): del self.__field_fax 
3200   
3201      fax=property(__getfield_fax, __setfield_fax, __delfield_fax, None) 
3202   
3203 -    def __getfield_cell2(self): 
3204          try: self.__field_cell2 
3205          except: 
3206              self.__field_cell2=ss_number_entry() 
3207          return self.__field_cell2.getvalue() 
3208   
3209 -    def __setfield_cell2(self, value): 
3210          if isinstance(value,ss_number_entry): 
3211              self.__field_cell2=value 
3212          else: 
3213              self.__field_cell2=ss_number_entry(value,) 
3214   
3215 -    def __delfield_cell2(self): del self.__field_cell2 
3216   
3217      cell2=property(__getfield_cell2, __setfield_cell2, __delfield_cell2, None) 
3218   
3219 -    def __getfield_group(self): 
3220          try: self.__field_group 
3221          except: 
3222              self.__field_group=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
3223          return self.__field_group.getvalue() 
3224   
3225 -    def __setfield_group(self, value): 
3226          if isinstance(value,UINT): 
3227              self.__field_group=value 
3228          else: 
3229              self.__field_group=UINT(value,**{'sizeinbytes': 1,  'default': 0 }) 
3230   
3231 -    def __delfield_group(self): del self.__field_group 
3232   
3233      group=property(__getfield_group, __setfield_group, __delfield_group, None) 
3234   
3235 -    def __getfield_street(self): 
3236          try: self.__field_street 
3237          except: 
3238              self.__field_street=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'maxsizeinbytes': PB_MAX_STREET_LEN,                'raiseontruncate': False,                'default': '' }) 
3239          return self.__field_street.getvalue() 
3240   
3241 -    def __setfield_street(self, value): 
3242          if isinstance(value,USTRING): 
3243              self.__field_street=value 
3244          else: 
3245              self.__field_street=USTRING(value,**{ 'terminator': 0,                'encoding': ENCODING,                'maxsizeinbytes': PB_MAX_STREET_LEN,                'raiseontruncate': False,                'default': '' }) 
3246   
3247 -    def __delfield_street(self): del self.__field_street 
3248   
3249      street=property(__getfield_street, __setfield_street, __delfield_street, None) 
3250   
3251 -    def __getfield_city(self): 
3252          try: self.__field_city 
3253          except: 
3254              self.__field_city=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'maxsizeinbytes': PB_MAX_CITY_LEN,                'raiseontruncate': False,                'default': '' }) 
3255          return self.__field_city.getvalue() 
3256   
3257 -    def __setfield_city(self, value): 
3258          if isinstance(value,USTRING): 
3259              self.__field_city=value 
3260          else: 
3261              self.__field_city=USTRING(value,**{ 'terminator': 0,                'encoding': ENCODING,                'maxsizeinbytes': PB_MAX_CITY_LEN,                'raiseontruncate': False,                'default': '' }) 
3262   
3263 -    def __delfield_city(self): del self.__field_city 
3264   
3265      city=property(__getfield_city, __setfield_city, __delfield_city, None) 
3266   
3267 -    def __getfield_state(self): 
3268          try: self.__field_state 
3269          except: 
3270              self.__field_state=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'maxsizeinbytes': PB_MAX_STATE_LEN,                'raiseontruncate': False,                'default': '' }) 
3271          return self.__field_state.getvalue() 
3272   
3273 -    def __setfield_state(self, value): 
3274          if isinstance(value,USTRING): 
3275              self.__field_state=value 
3276          else: 
3277              self.__field_state=USTRING(value,**{ 'terminator': 0,                'encoding': ENCODING,                'maxsizeinbytes': PB_MAX_STATE_LEN,                'raiseontruncate': False,                'default': '' }) 
3278   
3279 -    def __delfield_state(self): del self.__field_state 
3280   
3281      state=property(__getfield_state, __setfield_state, __delfield_state, None) 
3282   
3283 -    def __getfield_zipcode(self): 
3284          try: self.__field_zipcode 
3285          except: 
3286              self.__field_zipcode=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'maxsizeinbytes': PB_MAX_ZIP_LEN,                'raiseontruncate': False,                'default': '' }) 
3287          return self.__field_zipcode.getvalue() 
3288   
3289 -    def __setfield_zipcode(self, value): 
3290          if isinstance(value,USTRING): 
3291              self.__field_zipcode=value 
3292          else: 
3293              self.__field_zipcode=USTRING(value,**{ 'terminator': 0,                'encoding': ENCODING,                'maxsizeinbytes': PB_MAX_ZIP_LEN,                'raiseontruncate': False,                'default': '' }) 
3294   
3295 -    def __delfield_zipcode(self): del self.__field_zipcode 
3296   
3297      zipcode=property(__getfield_zipcode, __setfield_zipcode, __delfield_zipcode, None) 
3298   
3299 -    def __getfield_country(self): 
3300          try: self.__field_country 
3301          except: 
3302              self.__field_country=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'maxsizeinbytes': PB_MAX_COUNTRY_LEN,                'raiseontruncate': False,                'default': '' }) 
3303          return self.__field_country.getvalue() 
3304   
3305 -    def __setfield_country(self, value): 
3306          if isinstance(value,USTRING): 
3307              self.__field_country=value 
3308          else: 
3309              self.__field_country=USTRING(value,**{ 'terminator': 0,                'encoding': ENCODING,                'maxsizeinbytes': PB_MAX_COUNTRY_LEN,                'raiseontruncate': False,                'default': '' }) 
3310   
3311 -    def __delfield_country(self): del self.__field_country 
3312   
3313      country=property(__getfield_country, __setfield_country, __delfield_country, None) 
3314   
3315 -    def __getfield_im_name(self): 
3316          try: self.__field_im_name 
3317          except: 
3318              self.__field_im_name=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'maxsizeinbytes': PB_MAX_IMNAME_LEN,                'raiseontruncate': False,                'default': '' }) 
3319          return self.__field_im_name.getvalue() 
3320   
3321 -    def __setfield_im_name(self, value): 
3322          if isinstance(value,USTRING): 
3323              self.__field_im_name=value 
3324          else: 
3325              self.__field_im_name=USTRING(value,**{ 'terminator': 0,                'encoding': ENCODING,                'maxsizeinbytes': PB_MAX_IMNAME_LEN,                'raiseontruncate': False,                'default': '' }) 
3326   
3327 -    def __delfield_im_name(self): del self.__field_im_name 
3328   
3329      im_name=property(__getfield_im_name, __setfield_im_name, __delfield_im_name, None) 
3330   
3331 -    def __getfield_im_type(self): 
3332          try: self.__field_im_type 
3333          except: 
3334              self.__field_im_type=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
3335          return self.__field_im_type.getvalue() 
3336   
3337 -    def __setfield_im_type(self, value): 
3338          if isinstance(value,UINT): 
3339              self.__field_im_type=value 
3340          else: 
3341              self.__field_im_type=UINT(value,**{'sizeinbytes': 2,  'default': 0 }) 
3342   
3343 -    def __delfield_im_type(self): del self.__field_im_type 
3344   
3345      im_type=property(__getfield_im_type, __setfield_im_type, __delfield_im_type, None) 
3346   
3347 -    def iscontainer(self): 
3348          return True 
3349   
3350 -    def containerelements(self): 
3351          yield ('name', self.__field_name, None) 
3352          yield ('email', self.__field_email, None) 
3353          yield ('email2', self.__field_email2, None) 
3354          yield ('note', self.__field_note, None) 
3355          yield ('wallpaper', self.__field_wallpaper, None) 
3356          yield ('wallpaper_range', self.__field_wallpaper_range, None) 
3357          yield ('home', self.__field_home, None) 
3358          yield ('work', self.__field_work, None) 
3359          yield ('cell', self.__field_cell, None) 
3360          yield ('dummy', self.__field_dummy, None) 
3361          yield ('fax', self.__field_fax, None) 
3362          yield ('cell2', self.__field_cell2, None) 
3363          yield ('group', self.__field_group, None) 
3364          yield ('street', self.__field_street, None) 
3365          yield ('city', self.__field_city, None) 
3366          yield ('state', self.__field_state, None) 
3367          yield ('zipcode', self.__field_zipcode, None) 
3368          yield ('country', self.__field_country, None) 
3369          yield ('im_name', self.__field_im_name, None) 
3370          yield ('im_type', self.__field_im_type, None) 
3371   
3372 -    def _set_address(self, addr): 
3373          # set address fields based on BitPim phonebook address dict 
3374          if not isinstance(addr, dict): 
3375              raise TypeError('addr must be of type dict') 
3376          self.street=addr.get('street', '') 
3377          self.city=addr.get('city', '') 
3378          self.state=addr.get('state', '') 
3379          self.zipcode=addr.get('postalcode', '') 
3380          self.country=addr.get('country', '') 
3381 -    def _get_address(self): 
3382          # return address items in BitPim phonebook address dict 
3383          return { 'street': self.street, 'city': self.city, 
3384                   'state': self.state, 'postalcode': self.zipcode, 
3385                   'country': self.country } 
3386      address=property(fget=_get_address, fset=_set_address) 
3387   
3388   
3389   
3390   
3391 -class ss_pb_write_req(BaseProtogenClass): 
3392      __fields=['hdr', 'entry'] 
3393   
3394 -    def __init__(self, *args, **kwargs): 
3395          dict={} 
3396          # What was supplied to this function 
3397          dict.update(kwargs) 
3398          # Parent constructor 
3399          super(ss_pb_write_req,self).__init__(**dict) 
3400          if self.__class__ is ss_pb_write_req: 
3401              self._update(args,dict) 
3402   
3403   
3404 -    def getfields(self): 
3405          return self.__fields 
3406   
3407   
3408 -    def _update(self, args, kwargs): 
3409          super(ss_pb_write_req,self)._update(args,kwargs) 
3410          keys=kwargs.keys() 
3411          for key in keys: 
3412              if key in self.__fields: 
3413                  setattr(self, key, kwargs[key]) 
3414                  del kwargs[key] 
3415          # Were any unrecognized kwargs passed in? 
3416          if __debug__: 
3417              self._complainaboutunusedargs(ss_pb_write_req,kwargs) 
3418          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
3419          # Make all P fields that haven't already been constructed 
3420   
3421   
3422 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3423          'Writes this packet to the supplied buffer' 
3424          self._bufferstartoffset=buf.getcurrentoffset() 
3425          try: self.__field_hdr 
3426          except: 
3427              self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_WRITE }) 
3428          self.__field_hdr.writetobuffer(buf) 
3429          try: self.__field__gen_p_samsungschu750_398 
3430          except: 
3431              self.__field__gen_p_samsungschu750_398=DONTCARE(**{'sizeinbytes': 1}) 
3432          self.__field__gen_p_samsungschu750_398.writetobuffer(buf) 
3433          self.__field_entry.writetobuffer(buf) 
3434          self._bufferendoffset=buf.getcurrentoffset() 
3435          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3436   
3437   
3438 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3439          'Reads this packet from the supplied buffer' 
3440          self._bufferstartoffset=buf.getcurrentoffset() 
3441          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3442          self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_WRITE }) 
3443          self.__field_hdr.readfrombuffer(buf) 
3444          self.__field__gen_p_samsungschu750_398=DONTCARE(**{'sizeinbytes': 1}) 
3445          self.__field__gen_p_samsungschu750_398.readfrombuffer(buf) 
3446          self.__field_entry=ss_pb_entry() 
3447          self.__field_entry.readfrombuffer(buf) 
3448          self._bufferendoffset=buf.getcurrentoffset() 
3449   
3450   
3451 -    def __getfield_hdr(self): 
3452          try: self.__field_hdr 
3453          except: 
3454              self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_WRITE }) 
3455          return self.__field_hdr.getvalue() 
3456   
3457 -    def __setfield_hdr(self, value): 
3458          if isinstance(value,ss_cmd_hdr): 
3459              self.__field_hdr=value 
3460          else: 
3461              self.__field_hdr=ss_cmd_hdr(value,**{ 'command': SS_CMD_PB_WRITE }) 
3462   
3463 -    def __delfield_hdr(self): del self.__field_hdr 
3464   
3465      hdr=property(__getfield_hdr, __setfield_hdr, __delfield_hdr, None) 
3466   
3467 -    def __getfield_entry(self): 
3468          return self.__field_entry.getvalue() 
3469   
3470 -    def __setfield_entry(self, value): 
3471          if isinstance(value,ss_pb_entry): 
3472              self.__field_entry=value 
3473          else: 
3474              self.__field_entry=ss_pb_entry(value,) 
3475   
3476 -    def __delfield_entry(self): del self.__field_entry 
3477   
3478      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
3479   
3480 -    def iscontainer(self): 
3481          return True 
3482   
3483 -    def containerelements(self): 
3484          yield ('hdr', self.__field_hdr, None) 
3485          yield ('entry', self.__field_entry, None) 
3486   
3487   
3488   
3489   
3490 -class ss_pb_write_resp(BaseProtogenClass): 
3491      # Read-From-Buffer-Only Class 
3492      __fields=['hdr', 'index'] 
3493   
3494 -    def __init__(self, *args, **kwargs): 
3495          dict={} 
3496          # What was supplied to this function 
3497          dict.update(kwargs) 
3498          # Parent constructor 
3499          super(ss_pb_write_resp,self).__init__(**dict) 
3500          if self.__class__ is ss_pb_write_resp: 
3501              self._update(args,dict) 
3502   
3503   
3504 -    def getfields(self): 
3505          return self.__fields 
3506   
3507   
3508 -    def _update(self, args, kwargs): 
3509          super(ss_pb_write_resp,self)._update(args,kwargs) 
3510          keys=kwargs.keys() 
3511          for key in keys: 
3512              if key in self.__fields: 
3513                  setattr(self, key, kwargs[key]) 
3514                  del kwargs[key] 
3515          # Were any unrecognized kwargs passed in? 
3516          if __debug__: 
3517              self._complainaboutunusedargs(ss_pb_write_resp,kwargs) 
3518          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
3519          # Make all P fields that haven't already been constructed 
3520   
3521   
3522 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3523          'Writes this packet to the supplied buffer' 
3524          raise NotImplementedError 
3525   
3526   
3527 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3528          'Reads this packet from the supplied buffer' 
3529          self._bufferstartoffset=buf.getcurrentoffset() 
3530          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3531          self.__field_hdr=ss_cmd_hdr() 
3532          self.__field_hdr.readfrombuffer(buf) 
3533          DONTCARE(**{'sizeinbytes': 1}).readfrombuffer(buf) 
3534          self.__field_index=UINT(**{'sizeinbytes': 2}) 
3535          self.__field_index.readfrombuffer(buf) 
3536          self._bufferendoffset=buf.getcurrentoffset() 
3537   
3538   
3539 -    def __getfield_hdr(self): 
3540          return self.__field_hdr.getvalue() 
3541   
3542 -    def __setfield_hdr(self, value): 
3543          if isinstance(value,ss_cmd_hdr): 
3544              self.__field_hdr=value 
3545          else: 
3546              self.__field_hdr=ss_cmd_hdr(value,) 
3547   
3548 -    def __delfield_hdr(self): del self.__field_hdr 
3549   
3550      hdr=property(__getfield_hdr, __setfield_hdr, __delfield_hdr, None) 
3551   
3552 -    def __getfield_index(self): 
3553          return self.__field_index.getvalue() 
3554   
3555 -    def __setfield_index(self, value): 
3556          if isinstance(value,UINT): 
3557              self.__field_index=value 
3558          else: 
3559              self.__field_index=UINT(value,**{'sizeinbytes': 2}) 
3560   
3561 -    def __delfield_index(self): del self.__field_index 
3562   
3563      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
3564   
3565 -    def iscontainer(self): 
3566          return True 
3567   
3568 -    def containerelements(self): 
3569          yield ('hdr', self.__field_hdr, None) 
3570          yield ('index', self.__field_index, None) 
3571   
3572   
3573   
3574   
3575 -class cl_list(BaseProtogenClass): 
3576      # Read-From-Buffer-Only Class 
3577      __fields=['index'] 
3578   
3579 -    def __init__(self, *args, **kwargs): 
3580          dict={} 
3581          # What was supplied to this function 
3582          dict.update(kwargs) 
3583          # Parent constructor 
3584          super(cl_list,self).__init__(**dict) 
3585          if self.__class__ is cl_list: 
3586              self._update(args,dict) 
3587   
3588   
3589 -    def getfields(self): 
3590          return self.__fields 
3591   
3592   
3593 -    def _update(self, args, kwargs): 
3594          super(cl_list,self)._update(args,kwargs) 
3595          keys=kwargs.keys() 
3596          for key in keys: 
3597              if key in self.__fields: 
3598                  setattr(self, key, kwargs[key]) 
3599                  del kwargs[key] 
3600          # Were any unrecognized kwargs passed in? 
3601          if __debug__: 
3602              self._complainaboutunusedargs(cl_list,kwargs) 
3603          if len(args): 
3604              dict2={'sizeinbytes': 2} 
3605              dict2.update(kwargs) 
3606              kwargs=dict2 
3607              self.__field_index=UINT(*args,**dict2) 
3608          # Make all P fields that haven't already been constructed 
3609   
3610   
3611 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3612          'Writes this packet to the supplied buffer' 
3613          raise NotImplementedError 
3614   
3615   
3616 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3617          'Reads this packet from the supplied buffer' 
3618          self._bufferstartoffset=buf.getcurrentoffset() 
3619          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3620          self.__field_index=UINT(**{'sizeinbytes': 2}) 
3621          self.__field_index.readfrombuffer(buf) 
3622          self._bufferendoffset=buf.getcurrentoffset() 
3623   
3624   
3625 -    def __getfield_index(self): 
3626          return self.__field_index.getvalue() 
3627   
3628 -    def __setfield_index(self, value): 
3629          if isinstance(value,UINT): 
3630              self.__field_index=value 
3631          else: 
3632              self.__field_index=UINT(value,**{'sizeinbytes': 2}) 
3633   
3634 -    def __delfield_index(self): del self.__field_index 
3635   
3636      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
3637   
3638 -    def iscontainer(self): 
3639          return True 
3640   
3641 -    def containerelements(self): 
3642          yield ('index', self.__field_index, None) 
3643   
3644   
3645   
3646   
3647 -class cl_index_file(BaseProtogenClass): 
3648      # Read-From-Buffer-Only Class 
3649      __fields=['incoming', 'outgoing', 'missed', 'incoming_count', 'outgoing_count', 'missed_count'] 
3650   
3651 -    def __init__(self, *args, **kwargs): 
3652          dict={} 
3653          # What was supplied to this function 
3654          dict.update(kwargs) 
3655          # Parent constructor 
3656          super(cl_index_file,self).__init__(**dict) 
3657          if self.__class__ is cl_index_file: 
3658              self._update(args,dict) 
3659   
3660   
3661 -    def getfields(self): 
3662          return self.__fields 
3663   
3664   
3665 -    def _update(self, args, kwargs): 
3666          super(cl_index_file,self)._update(args,kwargs) 
3667          keys=kwargs.keys() 
3668          for key in keys: 
3669              if key in self.__fields: 
3670                  setattr(self, key, kwargs[key]) 
3671                  del kwargs[key] 
3672          # Were any unrecognized kwargs passed in? 
3673          if __debug__: 
3674              self._complainaboutunusedargs(cl_index_file,kwargs) 
3675          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
3676          # Make all P fields that haven't already been constructed 
3677   
3678   
3679 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3680          'Writes this packet to the supplied buffer' 
3681          raise NotImplementedError 
3682   
3683   
3684 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3685          'Reads this packet from the supplied buffer' 
3686          self._bufferstartoffset=buf.getcurrentoffset() 
3687          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3688          self.__field_incoming=LIST(**{ 'length': CL_MAX_ENTRIES,             'elementclass': cl_list }) 
3689          self.__field_incoming.readfrombuffer(buf) 
3690          self.__field_outgoing=LIST(**{ 'length': CL_MAX_ENTRIES,             'elementclass': cl_list }) 
3691          self.__field_outgoing.readfrombuffer(buf) 
3692          self.__field_missed=LIST(**{ 'length': CL_MAX_ENTRIES,             'elementclass': cl_list }) 
3693          self.__field_missed.readfrombuffer(buf) 
3694          DONTCARE(**{'sizeinbytes': 1374}).readfrombuffer(buf) 
3695          self.__field_incoming_count=UINT(**{'sizeinbytes': 4}) 
3696          self.__field_incoming_count.readfrombuffer(buf) 
3697          self.__field_outgoing_count=UINT(**{'sizeinbytes': 4}) 
3698          self.__field_outgoing_count.readfrombuffer(buf) 
3699          self.__field_missed_count=UINT(**{'sizeinbytes': 4}) 
3700          self.__field_missed_count.readfrombuffer(buf) 
3701          self._bufferendoffset=buf.getcurrentoffset() 
3702   
3703   
3704 -    def __getfield_incoming(self): 
3705          return self.__field_incoming.getvalue() 
3706   
3707 -    def __setfield_incoming(self, value): 
3708          if isinstance(value,LIST): 
3709              self.__field_incoming=value 
3710          else: 
3711              self.__field_incoming=LIST(value,**{ 'length': CL_MAX_ENTRIES,             'elementclass': cl_list }) 
3712   
3713 -    def __delfield_incoming(self): del self.__field_incoming 
3714   
3715      incoming=property(__getfield_incoming, __setfield_incoming, __delfield_incoming, None) 
3716   
3717 -    def __getfield_outgoing(self): 
3718          return self.__field_outgoing.getvalue() 
3719   
3720 -    def __setfield_outgoing(self, value): 
3721          if isinstance(value,LIST): 
3722              self.__field_outgoing=value 
3723          else: 
3724              self.__field_outgoing=LIST(value,**{ 'length': CL_MAX_ENTRIES,             'elementclass': cl_list }) 
3725   
3726 -    def __delfield_outgoing(self): del self.__field_outgoing 
3727   
3728      outgoing=property(__getfield_outgoing, __setfield_outgoing, __delfield_outgoing, None) 
3729   
3730 -    def __getfield_missed(self): 
3731          return self.__field_missed.getvalue() 
3732   
3733 -    def __setfield_missed(self, value): 
3734          if isinstance(value,LIST): 
3735              self.__field_missed=value 
3736          else: 
3737              self.__field_missed=LIST(value,**{ 'length': CL_MAX_ENTRIES,             'elementclass': cl_list }) 
3738   
3739 -    def __delfield_missed(self): del self.__field_missed 
3740   
3741      missed=property(__getfield_missed, __setfield_missed, __delfield_missed, None) 
3742   
3743 -    def __getfield_incoming_count(self): 
3744          return self.__field_incoming_count.getvalue() 
3745   
3746 -    def __setfield_incoming_count(self, value): 
3747          if isinstance(value,UINT): 
3748              self.__field_incoming_count=value 
3749          else: 
3750              self.__field_incoming_count=UINT(value,**{'sizeinbytes': 4}) 
3751   
3752 -    def __delfield_incoming_count(self): del self.__field_incoming_count 
3753   
3754      incoming_count=property(__getfield_incoming_count, __setfield_incoming_count, __delfield_incoming_count, None) 
3755   
3756 -    def __getfield_outgoing_count(self): 
3757          return self.__field_outgoing_count.getvalue() 
3758   
3759 -    def __setfield_outgoing_count(self, value): 
3760          if isinstance(value,UINT): 
3761              self.__field_outgoing_count=value 
3762          else: 
3763              self.__field_outgoing_count=UINT(value,**{'sizeinbytes': 4}) 
3764   
3765 -    def __delfield_outgoing_count(self): del self.__field_outgoing_count 
3766   
3767      outgoing_count=property(__getfield_outgoing_count, __setfield_outgoing_count, __delfield_outgoing_count, None) 
3768   
3769 -    def __getfield_missed_count(self): 
3770          return self.__field_missed_count.getvalue() 
3771   
3772 -    def __setfield_missed_count(self, value): 
3773          if isinstance(value,UINT): 
3774              self.__field_missed_count=value 
3775          else: 
3776              self.__field_missed_count=UINT(value,**{'sizeinbytes': 4}) 
3777   
3778 -    def __delfield_missed_count(self): del self.__field_missed_count 
3779   
3780      missed_count=property(__getfield_missed_count, __setfield_missed_count, __delfield_missed_count, None) 
3781   
3782 -    def iscontainer(self): 
3783          return True 
3784   
3785 -    def containerelements(self): 
3786          yield ('incoming', self.__field_incoming, None) 
3787          yield ('outgoing', self.__field_outgoing, None) 
3788          yield ('missed', self.__field_missed, None) 
3789          yield ('incoming_count', self.__field_incoming_count, None) 
3790          yield ('outgoing_count', self.__field_outgoing_count, None) 
3791          yield ('missed_count', self.__field_missed_count, None) 
3792   
3793   
3794   
3795   
3796 -class cl_file(BaseProtogenClass): 
3797      # Read-From-Buffer-Only Class 
3798      __fields=['cl_type', 'number', 'datetime', 'duration'] 
3799   
3800 -    def __init__(self, *args, **kwargs): 
3801          dict={} 
3802          # What was supplied to this function 
3803          dict.update(kwargs) 
3804          # Parent constructor 
3805          super(cl_file,self).__init__(**dict) 
3806          if self.__class__ is cl_file: 
3807              self._update(args,dict) 
3808   
3809   
3810 -    def getfields(self): 
3811          return self.__fields 
3812   
3813   
3814 -    def _update(self, args, kwargs): 
3815          super(cl_file,self)._update(args,kwargs) 
3816          keys=kwargs.keys() 
3817          for key in keys: 
3818              if key in self.__fields: 
3819                  setattr(self, key, kwargs[key]) 
3820                  del kwargs[key] 
3821          # Were any unrecognized kwargs passed in? 
3822          if __debug__: 
3823              self._complainaboutunusedargs(cl_file,kwargs) 
3824          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
3825          # Make all P fields that haven't already been constructed 
3826   
3827   
3828 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3829          'Writes this packet to the supplied buffer' 
3830          raise NotImplementedError 
3831   
3832   
3833 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3834          'Reads this packet from the supplied buffer' 
3835          self._bufferstartoffset=buf.getcurrentoffset() 
3836          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3837          self.__field_cl_type=UINT(**{'sizeinbytes': 1}) 
3838          self.__field_cl_type.readfrombuffer(buf) 
3839          self.__field_number=STRING(**{'sizeinbytes': 51,  'terminator': 0 }) 
3840          self.__field_number.readfrombuffer(buf) 
3841          self.__field_datetime=DateTime2(**{'sizeinbytes': 4}) 
3842          self.__field_datetime.readfrombuffer(buf) 
3843          DONTCARE(**{'sizeinbytes': 4}).readfrombuffer(buf) 
3844          self.__field_duration=UINT(**{'sizeinbytes': 4}) 
3845          self.__field_duration.readfrombuffer(buf) 
3846          self._bufferendoffset=buf.getcurrentoffset() 
3847   
3848   
3849 -    def __getfield_cl_type(self): 
3850          return self.__field_cl_type.getvalue() 
3851   
3852 -    def __setfield_cl_type(self, value): 
3853          if isinstance(value,UINT): 
3854              self.__field_cl_type=value 
3855          else: 
3856              self.__field_cl_type=UINT(value,**{'sizeinbytes': 1}) 
3857   
3858 -    def __delfield_cl_type(self): del self.__field_cl_type 
3859   
3860      cl_type=property(__getfield_cl_type, __setfield_cl_type, __delfield_cl_type, None) 
3861   
3862 -    def __getfield_number(self): 
3863          return self.__field_number.getvalue() 
3864   
3865 -    def __setfield_number(self, value): 
3866          if isinstance(value,STRING): 
3867              self.__field_number=value 
3868          else: 
3869              self.__field_number=STRING(value,**{'sizeinbytes': 51,  'terminator': 0 }) 
3870   
3871 -    def __delfield_number(self): del self.__field_number 
3872   
3873      number=property(__getfield_number, __setfield_number, __delfield_number, None) 
3874   
3875 -    def __getfield_datetime(self): 
3876          return self.__field_datetime.getvalue() 
3877   
3878 -    def __setfield_datetime(self, value): 
3879          if isinstance(value,DateTime2): 
3880              self.__field_datetime=value 
3881          else: 
3882              self.__field_datetime=DateTime2(value,**{'sizeinbytes': 4}) 
3883   
3884 -    def __delfield_datetime(self): del self.__field_datetime 
3885   
3886      datetime=property(__getfield_datetime, __setfield_datetime, __delfield_datetime, None) 
3887   
3888 -    def __getfield_duration(self): 
3889          return self.__field_duration.getvalue() 
3890   
3891 -    def __setfield_duration(self, value): 
3892          if isinstance(value,UINT): 
3893              self.__field_duration=value 
3894          else: 
3895              self.__field_duration=UINT(value,**{'sizeinbytes': 4}) 
3896   
3897 -    def __delfield_duration(self): del self.__field_duration 
3898   
3899      duration=property(__getfield_duration, __setfield_duration, __delfield_duration, None) 
3900   
3901 -    def iscontainer(self): 
3902          return True 
3903   
3904 -    def containerelements(self): 
3905          yield ('cl_type', self.__field_cl_type, None) 
3906          yield ('number', self.__field_number, None) 
3907          yield ('datetime', self.__field_datetime, None) 
3908          yield ('duration', self.__field_duration, None) 
3909   
3910      @property 
3911 -    def valid(self): 
3912          global CL_VALID_TYPE 
3913          return bool(self.cl_type in CL_VALID_TYPE and self.number) 
3914   
3915   
3916   
3917   
3918 -class CalIndexEntry(BaseProtogenClass): 
3919      __fields=['index'] 
3920   
3921 -    def __init__(self, *args, **kwargs): 
3922          dict={} 
3923          # What was supplied to this function 
3924          dict.update(kwargs) 
3925          # Parent constructor 
3926          super(CalIndexEntry,self).__init__(**dict) 
3927          if self.__class__ is CalIndexEntry: 
3928              self._update(args,dict) 
3929   
3930   
3931 -    def getfields(self): 
3932          return self.__fields 
3933   
3934   
3935 -    def _update(self, args, kwargs): 
3936          super(CalIndexEntry,self)._update(args,kwargs) 
3937          keys=kwargs.keys() 
3938          for key in keys: 
3939              if key in self.__fields: 
3940                  setattr(self, key, kwargs[key]) 
3941                  del kwargs[key] 
3942          # Were any unrecognized kwargs passed in? 
3943          if __debug__: 
3944              self._complainaboutunusedargs(CalIndexEntry,kwargs) 
3945          if len(args): 
3946              dict2={'sizeinbytes': 2,  'default': 0 } 
3947              dict2.update(kwargs) 
3948              kwargs=dict2 
3949              self.__field_index=UINT(*args,**dict2) 
3950          # Make all P fields that haven't already been constructed 
3951   
3952   
3953 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3954          'Writes this packet to the supplied buffer' 
3955          self._bufferstartoffset=buf.getcurrentoffset() 
3956          try: self.__field_index 
3957          except: 
3958              self.__field_index=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
3959          self.__field_index.writetobuffer(buf) 
3960          self._bufferendoffset=buf.getcurrentoffset() 
3961          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3962   
3963   
3964 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3965          'Reads this packet from the supplied buffer' 
3966          self._bufferstartoffset=buf.getcurrentoffset() 
3967          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3968          self.__field_index=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
3969          self.__field_index.readfrombuffer(buf) 
3970          self._bufferendoffset=buf.getcurrentoffset() 
3971   
3972   
3973 -    def __getfield_index(self): 
3974          try: self.__field_index 
3975          except: 
3976              self.__field_index=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
3977          return self.__field_index.getvalue() 
3978   
3979 -    def __setfield_index(self, value): 
3980          if isinstance(value,UINT): 
3981              self.__field_index=value 
3982          else: 
3983              self.__field_index=UINT(value,**{'sizeinbytes': 2,  'default': 0 }) 
3984   
3985 -    def __delfield_index(self): del self.__field_index 
3986   
3987      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
3988   
3989 -    def iscontainer(self): 
3990          return True 
3991   
3992 -    def containerelements(self): 
3993          yield ('index', self.__field_index, None) 
3994   
3995   
3996   
3997   
3998 -class CalIndexFile(BaseProtogenClass): 
3999      __fields=['next_index', 'numofevents', 'numofnotes', 'numofactiveevents', 'events', 'notes', 'activeevents'] 
4000   
4001 -    def __init__(self, *args, **kwargs): 
4002          dict={} 
4003          # What was supplied to this function 
4004          dict.update(kwargs) 
4005          # Parent constructor 
4006          super(CalIndexFile,self).__init__(**dict) 
4007          if self.__class__ is CalIndexFile: 
4008              self._update(args,dict) 
4009   
4010   
4011 -    def getfields(self): 
4012          return self.__fields 
4013   
4014   
4015 -    def _update(self, args, kwargs): 
4016          super(CalIndexFile,self)._update(args,kwargs) 
4017          keys=kwargs.keys() 
4018          for key in keys: 
4019              if key in self.__fields: 
4020                  setattr(self, key, kwargs[key]) 
4021                  del kwargs[key] 
4022          # Were any unrecognized kwargs passed in? 
4023          if __debug__: 
4024              self._complainaboutunusedargs(CalIndexFile,kwargs) 
4025          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
4026          # Make all P fields that haven't already been constructed 
4027   
4028   
4029 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
4030          'Writes this packet to the supplied buffer' 
4031          self._bufferstartoffset=buf.getcurrentoffset() 
4032          self.__field_next_index.writetobuffer(buf) 
4033          try: self.__field__gen_p_samsungschu750_440 
4034          except: 
4035              self.__field__gen_p_samsungschu750_440=DONTCARE(**{'sizeinbytes': 12}) 
4036          self.__field__gen_p_samsungschu750_440.writetobuffer(buf) 
4037          self.__field_numofevents.writetobuffer(buf) 
4038          try: self.__field__gen_p_samsungschu750_442 
4039          except: 
4040              self.__field__gen_p_samsungschu750_442=DONTCARE(**{'sizeinbytes': 6}) 
4041          self.__field__gen_p_samsungschu750_442.writetobuffer(buf) 
4042          self.__field_numofnotes.writetobuffer(buf) 
4043          try: self.__field__gen_p_samsungschu750_444 
4044          except: 
4045              self.__field__gen_p_samsungschu750_444=DONTCARE(**{'sizeinbytes': 6}) 
4046          self.__field__gen_p_samsungschu750_444.writetobuffer(buf) 
4047          self.__field_numofactiveevents.writetobuffer(buf) 
4048          try: self.__field__gen_p_samsungschu750_446 
4049          except: 
4050              self.__field__gen_p_samsungschu750_446=DONTCARE(**{'sizeinbytes': 112}) 
4051          self.__field__gen_p_samsungschu750_446.writetobuffer(buf) 
4052          try: self.__field_events 
4053          except: 
4054              self.__field_events=LIST(**{ 'elementclass': CalIndexEntry,             'length': 103,             'createdefault': True }) 
4055          self.__field_events.writetobuffer(buf) 
4056          try: self.__field_notes 
4057          except: 
4058              self.__field_notes=LIST(**{ 'elementclass': CalIndexEntry,             'length': 35,             'createdefault': True }) 
4059          self.__field_notes.writetobuffer(buf) 
4060          try: self.__field_activeevents 
4061          except: 
4062              self.__field_activeevents=LIST(**{ 'elementclass': CalIndexEntry,             'length': 319,             'createdefault': True }) 
4063          self.__field_activeevents.writetobuffer(buf) 
4064          self._bufferendoffset=buf.getcurrentoffset() 
4065          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
4066   
4067   
4068 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
4069          'Reads this packet from the supplied buffer' 
4070          self._bufferstartoffset=buf.getcurrentoffset() 
4071          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
4072          self.__field_next_index=UINT(**{'sizeinbytes': 2}) 
4073          self.__field_next_index.readfrombuffer(buf) 
4074          self.__field__gen_p_samsungschu750_440=DONTCARE(**{'sizeinbytes': 12}) 
4075          self.__field__gen_p_samsungschu750_440.readfrombuffer(buf) 
4076          self.__field_numofevents=UINT(**{'sizeinbytes': 2}) 
4077          self.__field_numofevents.readfrombuffer(buf) 
4078          self.__field__gen_p_samsungschu750_442=DONTCARE(**{'sizeinbytes': 6}) 
4079          self.__field__gen_p_samsungschu750_442.readfrombuffer(buf) 
4080          self.__field_numofnotes=UINT(**{'sizeinbytes': 2}) 
4081          self.__field_numofnotes.readfrombuffer(buf) 
4082          self.__field__gen_p_samsungschu750_444=DONTCARE(**{'sizeinbytes': 6}) 
4083          self.__field__gen_p_samsungschu750_444.readfrombuffer(buf) 
4084          self.__field_numofactiveevents=UINT(**{'sizeinbytes': 2}) 
4085          self.__field_numofactiveevents.readfrombuffer(buf) 
4086          self.__field__gen_p_samsungschu750_446=DONTCARE(**{'sizeinbytes': 112}) 
4087          self.__field__gen_p_samsungschu750_446.readfrombuffer(buf) 
4088          self.__field_events=LIST(**{ 'elementclass': CalIndexEntry,             'length': 103,             'createdefault': True }) 
4089          self.__field_events.readfrombuffer(buf) 
4090          self.__field_notes=LIST(**{ 'elementclass': CalIndexEntry,             'length': 35,             'createdefault': True }) 
4091          self.__field_notes.readfrombuffer(buf) 
4092          self.__field_activeevents=LIST(**{ 'elementclass': CalIndexEntry,             'length': 319,             'createdefault': True }) 
4093          self.__field_activeevents.readfrombuffer(buf) 
4094          self._bufferendoffset=buf.getcurrentoffset() 
4095   
4096   
4097 -    def __getfield_next_index(self): 
4098          return self.__field_next_index.getvalue() 
4099   
4100 -    def __setfield_next_index(self, value): 
4101          if isinstance(value,UINT): 
4102              self.__field_next_index=value 
4103          else: 
4104              self.__field_next_index=UINT(value,**{'sizeinbytes': 2}) 
4105   
4106 -    def __delfield_next_index(self): del self.__field_next_index 
4107   
4108      next_index=property(__getfield_next_index, __setfield_next_index, __delfield_next_index, None) 
4109   
4110 -    def __getfield_numofevents(self): 
4111          return self.__field_numofevents.getvalue() 
4112   
4113 -    def __setfield_numofevents(self, value): 
4114          if isinstance(value,UINT): 
4115              self.__field_numofevents=value 
4116          else: 
4117              self.__field_numofevents=UINT(value,**{'sizeinbytes': 2}) 
4118   
4119 -    def __delfield_numofevents(self): del self.__field_numofevents 
4120   
4121      numofevents=property(__getfield_numofevents, __setfield_numofevents, __delfield_numofevents, None) 
4122   
4123 -    def __getfield_numofnotes(self): 
4124          return self.__field_numofnotes.getvalue() 
4125   
4126 -    def __setfield_numofnotes(self, value): 
4127          if isinstance(value,UINT): 
4128              self.__field_numofnotes=value 
4129          else: 
4130              self.__field_numofnotes=UINT(value,**{'sizeinbytes': 2}) 
4131   
4132 -    def __delfield_numofnotes(self): del self.__field_numofnotes 
4133   
4134      numofnotes=property(__getfield_numofnotes, __setfield_numofnotes, __delfield_numofnotes, None) 
4135   
4136 -    def __getfield_numofactiveevents(self): 
4137          return self.__field_numofactiveevents.getvalue() 
4138   
4139 -    def __setfield_numofactiveevents(self, value): 
4140          if isinstance(value,UINT): 
4141              self.__field_numofactiveevents=value 
4142          else: 
4143              self.__field_numofactiveevents=UINT(value,**{'sizeinbytes': 2}) 
4144   
4145 -    def __delfield_numofactiveevents(self): del self.__field_numofactiveevents 
4146   
4147      numofactiveevents=property(__getfield_numofactiveevents, __setfield_numofactiveevents, __delfield_numofactiveevents, None) 
4148   
4149 -    def __getfield_events(self): 
4150          try: self.__field_events 
4151          except: 
4152              self.__field_events=LIST(**{ 'elementclass': CalIndexEntry,             'length': 103,             'createdefault': True }) 
4153          return self.__field_events.getvalue() 
4154   
4155 -    def __setfield_events(self, value): 
4156          if isinstance(value,LIST): 
4157              self.__field_events=value 
4158          else: 
4159              self.__field_events=LIST(value,**{ 'elementclass': CalIndexEntry,             'length': 103,             'createdefault': True }) 
4160   
4161 -    def __delfield_events(self): del self.__field_events 
4162   
4163      events=property(__getfield_events, __setfield_events, __delfield_events, None) 
4164   
4165 -    def __getfield_notes(self): 
4166          try: self.__field_notes 
4167          except: 
4168              self.__field_notes=LIST(**{ 'elementclass': CalIndexEntry,             'length': 35,             'createdefault': True }) 
4169          return self.__field_notes.getvalue() 
4170   
4171 -    def __setfield_notes(self, value): 
4172          if isinstance(value,LIST): 
4173              self.__field_notes=value 
4174          else: 
4175              self.__field_notes=LIST(value,**{ 'elementclass': CalIndexEntry,             'length': 35,             'createdefault': True }) 
4176   
4177 -    def __delfield_notes(self): del self.__field_notes 
4178   
4179      notes=property(__getfield_notes, __setfield_notes, __delfield_notes, None) 
4180   
4181 -    def __getfield_activeevents(self): 
4182          try: self.__field_activeevents 
4183          except: 
4184              self.__field_activeevents=LIST(**{ 'elementclass': CalIndexEntry,             'length': 319,             'createdefault': True }) 
4185          return self.__field_activeevents.getvalue() 
4186   
4187 -    def __setfield_activeevents(self, value): 
4188          if isinstance(value,LIST): 
4189              self.__field_activeevents=value 
4190          else: 
4191              self.__field_activeevents=LIST(value,**{ 'elementclass': CalIndexEntry,             'length': 319,             'createdefault': True }) 
4192   
4193 -    def __delfield_activeevents(self): del self.__field_activeevents 
4194   
4195      activeevents=property(__getfield_activeevents, __setfield_activeevents, __delfield_activeevents, None) 
4196   
4197 -    def iscontainer(self): 
4198          return True 
4199   
4200 -    def containerelements(self): 
4201          yield ('next_index', self.__field_next_index, None) 
4202          yield ('numofevents', self.__field_numofevents, None) 
4203          yield ('numofnotes', self.__field_numofnotes, None) 
4204          yield ('numofactiveevents', self.__field_numofactiveevents, None) 
4205          yield ('events', self.__field_events, None) 
4206          yield ('notes', self.__field_notes, None) 
4207          yield ('activeevents', self.__field_activeevents, None) 
4208   
4209   
4210   
4211   
4212 -class CalEntry(BaseProtogenClass): 
4213      __fields=['titlelen', 'title', 'start', 'start2', 'end', 'repeat', 'alarm', 'alert', 'reminder', 'duration', 'timezone', 'creationtime', 'modifiedtime', 'ringtonelen', 'ringtone'] 
4214   
4215 -    def __init__(self, *args, **kwargs): 
4216          dict={} 
4217          # What was supplied to this function 
4218          dict.update(kwargs) 
4219          # Parent constructor 
4220          super(CalEntry,self).__init__(**dict) 
4221          if self.__class__ is CalEntry: 
4222              self._update(args,dict) 
4223   
4224   
4225 -    def getfields(self): 
4226          return self.__fields 
4227   
4228   
4229 -    def _update(self, args, kwargs): 
4230          super(CalEntry,self)._update(args,kwargs) 
4231          keys=kwargs.keys() 
4232          for key in keys: 
4233              if key in self.__fields: 
4234                  setattr(self, key, kwargs[key]) 
4235                  del kwargs[key] 
4236          # Were any unrecognized kwargs passed in? 
4237          if __debug__: 
4238              self._complainaboutunusedargs(CalEntry,kwargs) 
4239          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
4240          # Make all P fields that haven't already been constructed 
4241   
4242   
4243 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
4244          'Writes this packet to the supplied buffer' 
4245          self._bufferstartoffset=buf.getcurrentoffset() 
4246          self.__field_titlelen.writetobuffer(buf) 
4247          self.__field_title.writetobuffer(buf) 
4248          self.__field_start.writetobuffer(buf) 
4249          try: self.__field_start2 
4250          except: 
4251              self.__field_start2=DateTime2(**{'sizeinbytes': 4,  'default': self.start }) 
4252          self.__field_start2.writetobuffer(buf) 
4253          self.__field_end.writetobuffer(buf) 
4254          try: self.__field__gen_p_samsungschu750_465 
4255          except: 
4256              self.__field__gen_p_samsungschu750_465=DONTCARE(**{'sizeinbytes': 1,  'default': '\x01' }) 
4257          self.__field__gen_p_samsungschu750_465.writetobuffer(buf) 
4258          self.__field_repeat.writetobuffer(buf) 
4259          try: self.__field__gen_p_samsungschu750_467 
4260          except: 
4261              self.__field__gen_p_samsungschu750_467=DONTCARE(**{'sizeinbytes': 1,  'default': '\x03' }) 
4262          self.__field__gen_p_samsungschu750_467.writetobuffer(buf) 
4263          self.__field_alarm.writetobuffer(buf) 
4264          self.__field_alert.writetobuffer(buf) 
4265          try: self.__field_reminder 
4266          except: 
4267              self.__field_reminder=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
4268          self.__field_reminder.writetobuffer(buf) 
4269          try: self.__field__gen_p_samsungschu750_471 
4270          except: 
4271              self.__field__gen_p_samsungschu750_471=DONTCARE(**{'sizeinbytes': 5}) 
4272          self.__field__gen_p_samsungschu750_471.writetobuffer(buf) 
4273          self.__field_duration.writetobuffer(buf) 
4274          self.__field_timezone.writetobuffer(buf) 
4275          self.__field_creationtime.writetobuffer(buf) 
4276          try: self.__field_modifiedtime 
4277          except: 
4278              self.__field_modifiedtime=DateTime2(**{'sizeinbytes': 4,  'default': self.creationtime }) 
4279          self.__field_modifiedtime.writetobuffer(buf) 
4280          self.__field_ringtonelen.writetobuffer(buf) 
4281          self.__field_ringtone.writetobuffer(buf) 
4282          try: self.__field__gen_p_samsungschu750_479 
4283          except: 
4284              self.__field__gen_p_samsungschu750_479=DONTCARE(**{'sizeinbytes': 2}) 
4285          self.__field__gen_p_samsungschu750_479.writetobuffer(buf) 
4286          self._bufferendoffset=buf.getcurrentoffset() 
4287          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
4288   
4289   
4290 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
4291          'Reads this packet from the supplied buffer' 
4292          self._bufferstartoffset=buf.getcurrentoffset() 
4293          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
4294          self.__field_titlelen=UINT(**{'sizeinbytes': 2}) 
4295          self.__field_titlelen.readfrombuffer(buf) 
4296          self.__field_title=USTRING(**{ 'sizeinbytes': self.titlelen,                'encoding': ENCODING,                'terminator': None }) 
4297          self.__field_title.readfrombuffer(buf) 
4298          self.__field_start=DateTime2(**{'sizeinbytes': 4}) 
4299          self.__field_start.readfrombuffer(buf) 
4300          self.__field_start2=DateTime2(**{'sizeinbytes': 4,  'default': self.start }) 
4301          self.__field_start2.readfrombuffer(buf) 
4302          self.__field_end=DateTime2(**{'sizeinbytes': 4}) 
4303          self.__field_end.readfrombuffer(buf) 
4304          self.__field__gen_p_samsungschu750_465=DONTCARE(**{'sizeinbytes': 1,  'default': '\x01' }) 
4305          self.__field__gen_p_samsungschu750_465.readfrombuffer(buf) 
4306          self.__field_repeat=UINT(**{'sizeinbytes': 1}) 
4307          self.__field_repeat.readfrombuffer(buf) 
4308          self.__field__gen_p_samsungschu750_467=DONTCARE(**{'sizeinbytes': 1,  'default': '\x03' }) 
4309          self.__field__gen_p_samsungschu750_467.readfrombuffer(buf) 
4310          self.__field_alarm=UINT(**{'sizeinbytes': 1}) 
4311          self.__field_alarm.readfrombuffer(buf) 
4312          self.__field_alert=UINT(**{'sizeinbytes': 1}) 
4313          self.__field_alert.readfrombuffer(buf) 
4314          self.__field_reminder=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
4315          self.__field_reminder.readfrombuffer(buf) 
4316          self.__field__gen_p_samsungschu750_471=DONTCARE(**{'sizeinbytes': 5}) 
4317          self.__field__gen_p_samsungschu750_471.readfrombuffer(buf) 
4318          self.__field_duration=UINT(**{'sizeinbytes': 4}) 
4319          self.__field_duration.readfrombuffer(buf) 
4320          self.__field_timezone=UINT(**{'sizeinbytes': 1}) 
4321          self.__field_timezone.readfrombuffer(buf) 
4322          self.__field_creationtime=DateTime2(**{'sizeinbytes': 4}) 
4323          self.__field_creationtime.readfrombuffer(buf) 
4324          self.__field_modifiedtime=DateTime2(**{'sizeinbytes': 4,  'default': self.creationtime }) 
4325          self.__field_modifiedtime.readfrombuffer(buf) 
4326          self.__field_ringtonelen=UINT(**{'sizeinbytes': 2}) 
4327          self.__field_ringtonelen.readfrombuffer(buf) 
4328          self.__field_ringtone=STRING(**{ 'sizeinbytes': self.ringtonelen,               'terminator': None }) 
4329          self.__field_ringtone.readfrombuffer(buf) 
4330          self.__field__gen_p_samsungschu750_479=DONTCARE(**{'sizeinbytes': 2}) 
4331          self.__field__gen_p_samsungschu750_479.readfrombuffer(buf) 
4332          self._bufferendoffset=buf.getcurrentoffset() 
4333   
4334   
4335 -    def __getfield_titlelen(self): 
4336          return self.__field_titlelen.getvalue() 
4337   
4338 -    def __setfield_titlelen(self, value): 
4339          if isinstance(value,UINT): 
4340              self.__field_titlelen=value 
4341          else: 
4342              self.__field_titlelen=UINT(value,**{'sizeinbytes': 2}) 
4343   
4344 -    def __delfield_titlelen(self): del self.__field_titlelen 
4345   
4346      titlelen=property(__getfield_titlelen, __setfield_titlelen, __delfield_titlelen, None) 
4347   
4348 -    def __getfield_title(self): 
4349          return self.__field_title.getvalue() 
4350   
4351 -    def __setfield_title(self, value): 
4352          if isinstance(value,USTRING): 
4353              self.__field_title=value 
4354          else: 
4355              self.__field_title=USTRING(value,**{ 'sizeinbytes': self.titlelen,                'encoding': ENCODING,                'terminator': None }) 
4356   
4357 -    def __delfield_title(self): del self.__field_title 
4358   
4359      title=property(__getfield_title, __setfield_title, __delfield_title, None) 
4360   
4361 -    def __getfield_start(self): 
4362          return self.__field_start.getvalue() 
4363   
4364 -    def __setfield_start(self, value): 
4365          if isinstance(value,DateTime2): 
4366              self.__field_start=value 
4367          else: 
4368              self.__field_start=DateTime2(value,**{'sizeinbytes': 4}) 
4369   
4370 -    def __delfield_start(self): del self.__field_start 
4371   
4372      start=property(__getfield_start, __setfield_start, __delfield_start, None) 
4373   
4374 -    def __getfield_start2(self): 
4375          try: self.__field_start2 
4376          except: 
4377              self.__field_start2=DateTime2(**{'sizeinbytes': 4,  'default': self.start }) 
4378          return self.__field_start2.getvalue() 
4379   
4380 -    def __setfield_start2(self, value): 
4381          if isinstance(value,DateTime2): 
4382              self.__field_start2=value 
4383          else: 
4384              self.__field_start2=DateTime2(value,**{'sizeinbytes': 4,  'default': self.start }) 
4385   
4386 -    def __delfield_start2(self): del self.__field_start2 
4387   
4388      start2=property(__getfield_start2, __setfield_start2, __delfield_start2, None) 
4389   
4390 -    def __getfield_end(self): 
4391          return self.__field_end.getvalue() 
4392   
4393 -    def __setfield_end(self, value): 
4394          if isinstance(value,DateTime2): 
4395              self.__field_end=value 
4396          else: 
4397              self.__field_end=DateTime2(value,**{'sizeinbytes': 4}) 
4398   
4399 -    def __delfield_end(self): del self.__field_end 
4400   
4401      end=property(__getfield_end, __setfield_end, __delfield_end, None) 
4402   
4403 -    def __getfield_repeat(self): 
4404          return self.__field_repeat.getvalue() 
4405   
4406 -    def __setfield_repeat(self, value): 
4407          if isinstance(value,UINT): 
4408              self.__field_repeat=value 
4409          else: 
4410              self.__field_repeat=UINT(value,**{'sizeinbytes': 1}) 
4411   
4412 -    def __delfield_repeat(self): del self.__field_repeat 
4413   
4414      repeat=property(__getfield_repeat, __setfield_repeat, __delfield_repeat, None) 
4415   
4416 -    def __getfield_alarm(self): 
4417          return self.__field_alarm.getvalue() 
4418   
4419 -    def __setfield_alarm(self, value): 
4420          if isinstance(value,UINT): 
4421              self.__field_alarm=value 
4422          else: 
4423              self.__field_alarm=UINT(value,**{'sizeinbytes': 1}) 
4424   
4425 -    def __delfield_alarm(self): del self.__field_alarm 
4426   
4427      alarm=property(__getfield_alarm, __setfield_alarm, __delfield_alarm, None) 
4428   
4429 -    def __getfield_alert(self): 
4430          return self.__field_alert.getvalue() 
4431   
4432 -    def __setfield_alert(self, value): 
4433          if isinstance(value,UINT): 
4434              self.__field_alert=value 
4435          else: 
4436              self.__field_alert=UINT(value,**{'sizeinbytes': 1}) 
4437   
4438 -    def __delfield_alert(self): del self.__field_alert 
4439   
4440      alert=property(__getfield_alert, __setfield_alert, __delfield_alert, None) 
4441   
4442 -    def __getfield_reminder(self): 
4443          try: self.__field_reminder 
4444          except: 
4445              self.__field_reminder=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
4446          return self.__field_reminder.getvalue() 
4447   
4448 -    def __setfield_reminder(self, value): 
4449          if isinstance(value,UINT): 
4450              self.__field_reminder=value 
4451          else: 
4452              self.__field_reminder=UINT(value,**{'sizeinbytes': 1,  'default': 0 }) 
4453   
4454 -    def __delfield_reminder(self): del self.__field_reminder 
4455   
4456      reminder=property(__getfield_reminder, __setfield_reminder, __delfield_reminder, None) 
4457   
4458 -    def __getfield_duration(self): 
4459          return self.__field_duration.getvalue() 
4460   
4461 -    def __setfield_duration(self, value): 
4462          if isinstance(value,UINT): 
4463              self.__field_duration=value 
4464          else: 
4465              self.__field_duration=UINT(value,**{'sizeinbytes': 4}) 
4466   
4467 -    def __delfield_duration(self): del self.__field_duration 
4468   
4469      duration=property(__getfield_duration, __setfield_duration, __delfield_duration, None) 
4470   
4471 -    def __getfield_timezone(self): 
4472          return self.__field_timezone.getvalue() 
4473   
4474 -    def __setfield_timezone(self, value): 
4475          if isinstance(value,UINT): 
4476              self.__field_timezone=value 
4477          else: 
4478              self.__field_timezone=UINT(value,**{'sizeinbytes': 1}) 
4479   
4480 -    def __delfield_timezone(self): del self.__field_timezone 
4481   
4482      timezone=property(__getfield_timezone, __setfield_timezone, __delfield_timezone, None) 
4483   
4484 -    def __getfield_creationtime(self): 
4485          return self.__field_creationtime.getvalue() 
4486   
4487 -    def __setfield_creationtime(self, value): 
4488          if isinstance(value,DateTime2): 
4489              self.__field_creationtime=value 
4490          else: 
4491              self.__field_creationtime=DateTime2(value,**{'sizeinbytes': 4}) 
4492   
4493 -    def __delfield_creationtime(self): del self.__field_creationtime 
4494   
4495      creationtime=property(__getfield_creationtime, __setfield_creationtime, __delfield_creationtime, None) 
4496   
4497 -    def __getfield_modifiedtime(self): 
4498          try: self.__field_modifiedtime 
4499          except: 
4500              self.__field_modifiedtime=DateTime2(**{'sizeinbytes': 4,  'default': self.creationtime }) 
4501          return self.__field_modifiedtime.getvalue() 
4502   
4503 -    def __setfield_modifiedtime(self, value): 
4504          if isinstance(value,DateTime2): 
4505              self.__field_modifiedtime=value 
4506          else: 
4507              self.__field_modifiedtime=DateTime2(value,**{'sizeinbytes': 4,  'default': self.creationtime }) 
4508   
4509 -    def __delfield_modifiedtime(self): del self.__field_modifiedtime 
4510   
4511      modifiedtime=property(__getfield_modifiedtime, __setfield_modifiedtime, __delfield_modifiedtime, None) 
4512   
4513 -    def __getfield_ringtonelen(self): 
4514          return self.__field_ringtonelen.getvalue() 
4515   
4516 -    def __setfield_ringtonelen(self, value): 
4517          if isinstance(value,UINT): 
4518              self.__field_ringtonelen=value 
4519          else: 
4520              self.__field_ringtonelen=UINT(value,**{'sizeinbytes': 2}) 
4521   
4522 -    def __delfield_ringtonelen(self): del self.__field_ringtonelen 
4523   
4524      ringtonelen=property(__getfield_ringtonelen, __setfield_ringtonelen, __delfield_ringtonelen, None) 
4525   
4526 -    def __getfield_ringtone(self): 
4527          return self.__field_ringtone.getvalue() 
4528   
4529 -    def __setfield_ringtone(self, value): 
4530          if isinstance(value,STRING): 
4531              self.__field_ringtone=value 
4532          else: 
4533              self.__field_ringtone=STRING(value,**{ 'sizeinbytes': self.ringtonelen,               'terminator': None }) 
4534   
4535 -    def __delfield_ringtone(self): del self.__field_ringtone 
4536   
4537      ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 
4538   
4539 -    def iscontainer(self): 
4540          return True 
4541   
4542 -    def containerelements(self): 
4543          yield ('titlelen', self.__field_titlelen, None) 
4544          yield ('title', self.__field_title, None) 
4545          yield ('start', self.__field_start, None) 
4546          yield ('start2', self.__field_start2, None) 
4547          yield ('end', self.__field_end, None) 
4548          yield ('repeat', self.__field_repeat, None) 
4549          yield ('alarm', self.__field_alarm, None) 
4550          yield ('alert', self.__field_alert, None) 
4551          yield ('reminder', self.__field_reminder, None) 
4552          yield ('duration', self.__field_duration, None) 
4553          yield ('timezone', self.__field_timezone, None) 
4554          yield ('creationtime', self.__field_creationtime, None) 
4555          yield ('modifiedtime', self.__field_modifiedtime, None) 
4556          yield ('ringtonelen', self.__field_ringtonelen, None) 
4557          yield ('ringtone', self.__field_ringtone, None) 
4558   
4559   
4560   
4561   
4562 -class NotePadEntry(BaseProtogenClass): 
4563      __fields=['textlen', 'text', 'creation', 'creation2', 'modified', 'modified2'] 
4564   
4565 -    def __init__(self, *args, **kwargs): 
4566          dict={} 
4567          # What was supplied to this function 
4568          dict.update(kwargs) 
4569          # Parent constructor 
4570          super(NotePadEntry,self).__init__(**dict) 
4571          if self.__class__ is NotePadEntry: 
4572              self._update(args,dict) 
4573   
4574   
4575 -    def getfields(self): 
4576          return self.__fields 
4577   
4578   
4579 -    def _update(self, args, kwargs): 
4580          super(NotePadEntry,self)._update(args,kwargs) 
4581          keys=kwargs.keys() 
4582          for key in keys: 
4583              if key in self.__fields: 
4584                  setattr(self, key, kwargs[key]) 
4585                  del kwargs[key] 
4586          # Were any unrecognized kwargs passed in? 
4587          if __debug__: 
4588              self._complainaboutunusedargs(NotePadEntry,kwargs) 
4589          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
4590          # Make all P fields that haven't already been constructed 
4591   
4592   
4593 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
4594          'Writes this packet to the supplied buffer' 
4595          self._bufferstartoffset=buf.getcurrentoffset() 
4596          self.__field_textlen.writetobuffer(buf) 
4597          self.__field_text.writetobuffer(buf) 
4598          self.__field_creation.writetobuffer(buf) 
4599          try: self.__field_creation2 
4600          except: 
4601              self.__field_creation2=DateTime2(**{'sizeinbytes': 4,  'default': self.creation }) 
4602          self.__field_creation2.writetobuffer(buf) 
4603          try: self.__field__gen_p_samsungschu750_488 
4604          except: 
4605              self.__field__gen_p_samsungschu750_488=DONTCARE(**{'sizeinbytes': 6}) 
4606          self.__field__gen_p_samsungschu750_488.writetobuffer(buf) 
4607          try: self.__field__gen_p_samsungschu750_489 
4608          except: 
4609              self.__field__gen_p_samsungschu750_489=DONTCARE(**{'sizeinbytes': 1,  'default': '\x05' }) 
4610          self.__field__gen_p_samsungschu750_489.writetobuffer(buf) 
4611          try: self.__field__gen_p_samsungschu750_490 
4612          except: 
4613              self.__field__gen_p_samsungschu750_490=DONTCARE(**{'sizeinbytes': 12}) 
4614          self.__field__gen_p_samsungschu750_490.writetobuffer(buf) 
4615          try: self.__field__gen_p_samsungschu750_491 
4616          except: 
4617              self.__field__gen_p_samsungschu750_491=DONTCARE(**{'sizeinbytes': 1,  'default': '\x30' }) 
4618          self.__field__gen_p_samsungschu750_491.writetobuffer(buf) 
4619          try: self.__field_modified 
4620          except: 
4621              self.__field_modified=DateTime2(**{'sizeinbytes': 4,  'default': self.creation }) 
4622          self.__field_modified.writetobuffer(buf) 
4623          try: self.__field_modified2 
4624          except: 
4625              self.__field_modified2=DateTime2(**{'sizeinbytes': 4,  'default': self.modified }) 
4626          self.__field_modified2.writetobuffer(buf) 
4627          try: self.__field__gen_p_samsungschu750_494 
4628          except: 
4629              self.__field__gen_p_samsungschu750_494=DONTCARE(**{'sizeinbytes': 4}) 
4630          self.__field__gen_p_samsungschu750_494.writetobuffer(buf) 
4631          self._bufferendoffset=buf.getcurrentoffset() 
4632          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
4633   
4634   
4635 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
4636          'Reads this packet from the supplied buffer' 
4637          self._bufferstartoffset=buf.getcurrentoffset() 
4638          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
4639          self.__field_textlen=UINT(**{'sizeinbytes': 2}) 
4640          self.__field_textlen.readfrombuffer(buf) 
4641          self.__field_text=USTRING(**{ 'terminator': None,                'encoding': ENCODING,                'sizeinbytes': self.textlen }) 
4642          self.__field_text.readfrombuffer(buf) 
4643          self.__field_creation=DateTime2(**{'sizeinbytes': 4}) 
4644          self.__field_creation.readfrombuffer(buf) 
4645          self.__field_creation2=DateTime2(**{'sizeinbytes': 4,  'default': self.creation }) 
4646          self.__field_creation2.readfrombuffer(buf) 
4647          self.__field__gen_p_samsungschu750_488=DONTCARE(**{'sizeinbytes': 6}) 
4648          self.__field__gen_p_samsungschu750_488.readfrombuffer(buf) 
4649          self.__field__gen_p_samsungschu750_489=DONTCARE(**{'sizeinbytes': 1,  'default': '\x05' }) 
4650          self.__field__gen_p_samsungschu750_489.readfrombuffer(buf) 
4651          self.__field__gen_p_samsungschu750_490=DONTCARE(**{'sizeinbytes': 12}) 
4652          self.__field__gen_p_samsungschu750_490.readfrombuffer(buf) 
4653          self.__field__gen_p_samsungschu750_491=DONTCARE(**{'sizeinbytes': 1,  'default': '\x30' }) 
4654          self.__field__gen_p_samsungschu750_491.readfrombuffer(buf) 
4655          self.__field_modified=DateTime2(**{'sizeinbytes': 4,  'default': self.creation }) 
4656          self.__field_modified.readfrombuffer(buf) 
4657          self.__field_modified2=DateTime2(**{'sizeinbytes': 4,  'default': self.modified }) 
4658          self.__field_modified2.readfrombuffer(buf) 
4659          self.__field__gen_p_samsungschu750_494=DONTCARE(**{'sizeinbytes': 4}) 
4660          self.__field__gen_p_samsungschu750_494.readfrombuffer(buf) 
4661          self._bufferendoffset=buf.getcurrentoffset() 
4662   
4663   
4664 -    def __getfield_textlen(self): 
4665          return self.__field_textlen.getvalue() 
4666   
4667 -    def __setfield_textlen(self, value): 
4668          if isinstance(value,UINT): 
4669              self.__field_textlen=value 
4670          else: 
4671              self.__field_textlen=UINT(value,**{'sizeinbytes': 2}) 
4672   
4673 -    def __delfield_textlen(self): del self.__field_textlen 
4674   
4675      textlen=property(__getfield_textlen, __setfield_textlen, __delfield_textlen, None) 
4676   
4677 -    def __getfield_text(self): 
4678          return self.__field_text.getvalue() 
4679   
4680 -    def __setfield_text(self, value): 
4681          if isinstance(value,USTRING): 
4682              self.__field_text=value 
4683          else: 
4684              self.__field_text=USTRING(value,**{ 'terminator': None,                'encoding': ENCODING,                'sizeinbytes': self.textlen }) 
4685   
4686 -    def __delfield_text(self): del self.__field_text 
4687   
4688      text=property(__getfield_text, __setfield_text, __delfield_text, None) 
4689   
4690 -    def __getfield_creation(self): 
4691          return self.__field_creation.getvalue() 
4692   
4693 -    def __setfield_creation(self, value): 
4694          if isinstance(value,DateTime2): 
4695              self.__field_creation=value 
4696          else: 
4697              self.__field_creation=DateTime2(value,**{'sizeinbytes': 4}) 
4698   
4699 -    def __delfield_creation(self): del self.__field_creation 
4700   
4701      creation=property(__getfield_creation, __setfield_creation, __delfield_creation, None) 
4702   
4703 -    def __getfield_creation2(self): 
4704          try: self.__field_creation2 
4705          except: 
4706              self.__field_creation2=DateTime2(**{'sizeinbytes': 4,  'default': self.creation }) 
4707          return self.__field_creation2.getvalue() 
4708   
4709 -    def __setfield_creation2(self, value): 
4710          if isinstance(value,DateTime2): 
4711              self.__field_creation2=value 
4712          else: 
4713              self.__field_creation2=DateTime2(value,**{'sizeinbytes': 4,  'default': self.creation }) 
4714   
4715 -    def __delfield_creation2(self): del self.__field_creation2 
4716   
4717      creation2=property(__getfield_creation2, __setfield_creation2, __delfield_creation2, None) 
4718   
4719 -    def __getfield_modified(self): 
4720          try: self.__field_modified 
4721          except: 
4722              self.__field_modified=DateTime2(**{'sizeinbytes': 4,  'default': self.creation }) 
4723          return self.__field_modified.getvalue() 
4724   
4725 -    def __setfield_modified(self, value): 
4726          if isinstance(value,DateTime2): 
4727              self.__field_modified=value 
4728          else: 
4729              self.__field_modified=DateTime2(value,**{'sizeinbytes': 4,  'default': self.creation }) 
4730   
4731 -    def __delfield_modified(self): del self.__field_modified 
4732   
4733      modified=property(__getfield_modified, __setfield_modified, __delfield_modified, None) 
4734   
4735 -    def __getfield_modified2(self): 
4736          try: self.__field_modified2 
4737          except: 
4738              self.__field_modified2=DateTime2(**{'sizeinbytes': 4,  'default': self.modified }) 
4739          return self.__field_modified2.getvalue() 
4740   
4741 -    def __setfield_modified2(self, value): 
4742          if isinstance(value,DateTime2): 
4743              self.__field_modified2=value 
4744          else: 
4745              self.__field_modified2=DateTime2(value,**{'sizeinbytes': 4,  'default': self.modified }) 
4746   
4747 -    def __delfield_modified2(self): del self.__field_modified2 
4748   
4749      modified2=property(__getfield_modified2, __setfield_modified2, __delfield_modified2, None) 
4750   
4751 -    def iscontainer(self): 
4752          return True 
4753   
4754 -    def containerelements(self): 
4755          yield ('textlen', self.__field_textlen, None) 
4756          yield ('text', self.__field_text, None) 
4757          yield ('creation', self.__field_creation, None) 
4758          yield ('creation2', self.__field_creation2, None) 
4759          yield ('modified', self.__field_modified, None) 
4760          yield ('modified2', self.__field_modified2, None) 
4761   
4762   
4763   
4764   
4765 -class pBOOL(BaseProtogenClass): 
4766      __fields=['value'] 
4767   
4768 -    def __init__(self, *args, **kwargs): 
4769          dict={} 
4770          # What was supplied to this function 
4771          dict.update(kwargs) 
4772          # Parent constructor 
4773          super(pBOOL,self).__init__(**dict) 
4774          if self.__class__ is pBOOL: 
4775              self._update(args,dict) 
4776   
4777   
4778 -    def getfields(self): 
4779          return self.__fields 
4780   
4781   
4782 -    def _update(self, args, kwargs): 
4783          super(pBOOL,self)._update(args,kwargs) 
4784          keys=kwargs.keys() 
4785          for key in keys: 
4786              if key in self.__fields: 
4787                  setattr(self, key, kwargs[key]) 
4788                  del kwargs[key] 
4789          # Were any unrecognized kwargs passed in? 
4790          if __debug__: 
4791              self._complainaboutunusedargs(pBOOL,kwargs) 
4792          if len(args): 
4793              dict2={'sizeinbytes': 'P'} 
4794              dict2.update(kwargs) 
4795              kwargs=dict2 
4796              self.__field_value=BOOL(*args,**dict2) 
4797          # Make all P fields that haven't already been constructed 
4798          try: self.__field_value 
4799          except: 
4800              self.__field_value=BOOL() 
4801   
4802   
4803 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
4804          'Writes this packet to the supplied buffer' 
4805          self._bufferstartoffset=buf.getcurrentoffset() 
4806          self._bufferendoffset=buf.getcurrentoffset() 
4807          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
4808   
4809   
4810 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
4811          'Reads this packet from the supplied buffer' 
4812          self._bufferstartoffset=buf.getcurrentoffset() 
4813          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
4814          self._bufferendoffset=buf.getcurrentoffset() 
4815   
4816   
4817 -    def __getfield_value(self): 
4818          return self.__field_value.getvalue() 
4819   
4820 -    def __setfield_value(self, value): 
4821          if isinstance(value,BOOL): 
4822              self.__field_value=value 
4823          else: 
4824              self.__field_value=BOOL(value,) 
4825   
4826 -    def __delfield_value(self): del self.__field_value 
4827   
4828      value=property(__getfield_value, __setfield_value, __delfield_value, None) 
4829   
4830 -    def iscontainer(self): 
4831          return True 
4832   
4833 -    def containerelements(self): 
4834          yield ('value', self.__field_value, None) 
4835   
4836   
4837   
4838   
4839 -class sms_header(BaseProtogenClass): 
4840      # Read-From-Buffer-Only Class 
4841      __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'] 
4842   
4843 -    def __init__(self, *args, **kwargs): 
4844          dict={} 
4845          # What was supplied to this function 
4846          dict.update(kwargs) 
4847          # Parent constructor 
4848          super(sms_header,self).__init__(**dict) 
4849          if self.__class__ is sms_header: 
4850              self._update(args,dict) 
4851   
4852   
4853 -    def getfields(self): 
4854          return self.__fields 
4855   
4856   
4857 -    def _update(self, args, kwargs): 
4858          super(sms_header,self)._update(args,kwargs) 
4859          keys=kwargs.keys() 
4860          for key in keys: 
4861              if key in self.__fields: 
4862                  setattr(self, key, kwargs[key]) 
4863                  del kwargs[key] 
4864          # Were any unrecognized kwargs passed in? 
4865          if __debug__: 
4866              self._complainaboutunusedargs(sms_header,kwargs) 
4867          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
4868          # Make all P fields that haven't already been constructed 
4869   
4870   
4871 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
4872          'Writes this packet to the supplied buffer' 
4873          raise NotImplementedError 
4874   
4875   
4876 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
4877          'Reads this packet from the supplied buffer' 
4878          self._bufferstartoffset=buf.getcurrentoffset() 
4879          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
4880          self.__field_index=UINT(**{'sizeinbytes': 2}) 
4881          self.__field_index.readfrombuffer(buf) 
4882          DONTCARE(**{'sizeinbytes': 1}).readfrombuffer(buf) 
4883          self.__field_msg_len=UINT(**{'sizeinbytes': 1}) 
4884          self.__field_msg_len.readfrombuffer(buf) 
4885          DONTCARE(**{'sizeinbytes': 1}).readfrombuffer(buf) 
4886          self.__field_callback_len=UINT(**{'sizeinbytes': 1}) 
4887          self.__field_callback_len.readfrombuffer(buf) 
4888          self.__field_bitmap1=UINT(**{'sizeinbytes': 1}) 
4889          self.__field_bitmap1.readfrombuffer(buf) 
4890          self.__field_bitmap2=UINT(**{'sizeinbytes': 1}) 
4891          self.__field_bitmap2.readfrombuffer(buf) 
4892          DONTCARE(**{'sizeinbytes': 6}).readfrombuffer(buf) 
4893          self.__field_body_len=UINT(**{'sizeinbytes': 2}) 
4894          self.__field_body_len.readfrombuffer(buf) 
4895          self.__field_file_type=UINT(**{'sizeinbytes': 2}) 
4896          self.__field_file_type.readfrombuffer(buf) 
4897          self.__field_msg_type=UINT(**{'sizeinbytes': 1}) 
4898          self.__field_msg_type.readfrombuffer(buf) 
4899          self.__field_enhance_delivery=UINT(**{'sizeinbytes': 1}) 
4900          self.__field_enhance_delivery.readfrombuffer(buf) 
4901          self.__field_is_txt_msg=pBOOL(**{ 'value': self.file_type==SMS_TXT_TYPE and self.msg_type in SMS_VALID_TYPE }) 
4902          self.__field_is_txt_msg.readfrombuffer(buf) 
4903          self.__field_in_msg=pBOOL(**{ 'value': self.msg_type==SMS_TYPE_IN }) 
4904          self.__field_in_msg.readfrombuffer(buf) 
4905          self.__field_sent_msg=pBOOL(**{ 'value': self.msg_type==SMS_TYPE_SENT }) 
4906          self.__field_sent_msg.readfrombuffer(buf) 
4907          self.__field_draft_msg=pBOOL(**{ 'value': self.msg_type==SMS_TYPE_DRAFT }) 
4908          self.__field_draft_msg.readfrombuffer(buf) 
4909          if self.is_txt_msg.value: 
4910              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) or (not self.bitmap2),            'has_1byte2': self.bitmap2 & SMS_FLG2_MSG,            'has_40bytes': self.bitmap1 & SMS_FLG1_HAS40 }) 
4911              self.__field_body.readfrombuffer(buf) 
4912          self._bufferendoffset=buf.getcurrentoffset() 
4913   
4914   
4915 -    def __getfield_index(self): 
4916          return self.__field_index.getvalue() 
4917   
4918 -    def __setfield_index(self, value): 
4919          if isinstance(value,UINT): 
4920              self.__field_index=value 
4921          else: 
4922              self.__field_index=UINT(value,**{'sizeinbytes': 2}) 
4923   
4924 -    def __delfield_index(self): del self.__field_index 
4925   
4926      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
4927   
4928 -    def __getfield_msg_len(self): 
4929          return self.__field_msg_len.getvalue() 
4930   
4931 -    def __setfield_msg_len(self, value): 
4932          if isinstance(value,UINT): 
4933              self.__field_msg_len=value 
4934          else: 
4935              self.__field_msg_len=UINT(value,**{'sizeinbytes': 1}) 
4936   
4937 -    def __delfield_msg_len(self): del self.__field_msg_len 
4938   
4939      msg_len=property(__getfield_msg_len, __setfield_msg_len, __delfield_msg_len, None) 
4940   
4941 -    def __getfield_callback_len(self): 
4942          return self.__field_callback_len.getvalue() 
4943   
4944 -    def __setfield_callback_len(self, value): 
4945          if isinstance(value,UINT): 
4946              self.__field_callback_len=value 
4947          else: 
4948              self.__field_callback_len=UINT(value,**{'sizeinbytes': 1}) 
4949   
4950 -    def __delfield_callback_len(self): del self.__field_callback_len 
4951   
4952      callback_len=property(__getfield_callback_len, __setfield_callback_len, __delfield_callback_len, None) 
4953   
4954 -    def __getfield_bitmap1(self): 
4955          return self.__field_bitmap1.getvalue() 
4956   
4957 -    def __setfield_bitmap1(self, value): 
4958          if isinstance(value,UINT): 
4959              self.__field_bitmap1=value 
4960          else: 
4961              self.__field_bitmap1=UINT(value,**{'sizeinbytes': 1}) 
4962   
4963 -    def __delfield_bitmap1(self): del self.__field_bitmap1 
4964   
4965      bitmap1=property(__getfield_bitmap1, __setfield_bitmap1, __delfield_bitmap1, None) 
4966   
4967 -    def __getfield_bitmap2(self): 
4968          return self.__field_bitmap2.getvalue() 
4969   
4970 -    def __setfield_bitmap2(self, value): 
4971          if isinstance(value,UINT): 
4972              self.__field_bitmap2=value 
4973          else: 
4974              self.__field_bitmap2=UINT(value,**{'sizeinbytes': 1}) 
4975   
4976 -    def __delfield_bitmap2(self): del self.__field_bitmap2 
4977   
4978      bitmap2=property(__getfield_bitmap2, __setfield_bitmap2, __delfield_bitmap2, None) 
4979   
4980 -    def __getfield_body_len(self): 
4981          return self.__field_body_len.getvalue() 
4982   
4983 -    def __setfield_body_len(self, value): 
4984          if isinstance(value,UINT): 
4985              self.__field_body_len=value 
4986          else: 
4987              self.__field_body_len=UINT(value,**{'sizeinbytes': 2}) 
4988   
4989 -    def __delfield_body_len(self): del self.__field_body_len 
4990   
4991      body_len=property(__getfield_body_len, __setfield_body_len, __delfield_body_len, None) 
4992   
4993 -    def __getfield_file_type(self): 
4994          return self.__field_file_type.getvalue() 
4995   
4996 -    def __setfield_file_type(self, value): 
4997          if isinstance(value,UINT): 
4998              self.__field_file_type=value 
4999          else: 
5000              self.__field_file_type=UINT(value,**{'sizeinbytes': 2}) 
5001   
5002 -    def __delfield_file_type(self): del self.__field_file_type 
5003   
5004      file_type=property(__getfield_file_type, __setfield_file_type, __delfield_file_type, None) 
5005   
5006 -    def __getfield_msg_type(self): 
5007          return self.__field_msg_type.getvalue() 
5008   
5009 -    def __setfield_msg_type(self, value): 
5010          if isinstance(value,UINT): 
5011              self.__field_msg_type=value 
5012          else: 
5013              self.__field_msg_type=UINT(value,**{'sizeinbytes': 1}) 
5014   
5015 -    def __delfield_msg_type(self): del self.__field_msg_type 
5016   
5017      msg_type=property(__getfield_msg_type, __setfield_msg_type, __delfield_msg_type, None) 
5018   
5019 -    def __getfield_enhance_delivery(self): 
5020          return self.__field_enhance_delivery.getvalue() 
5021   
5022 -    def __setfield_enhance_delivery(self, value): 
5023          if isinstance(value,UINT): 
5024              self.__field_enhance_delivery=value 
5025          else: 
5026              self.__field_enhance_delivery=UINT(value,**{'sizeinbytes': 1}) 
5027   
5028 -    def __delfield_enhance_delivery(self): del self.__field_enhance_delivery 
5029   
5030      enhance_delivery=property(__getfield_enhance_delivery, __setfield_enhance_delivery, __delfield_enhance_delivery, None) 
5031   
5032 -    def __getfield_is_txt_msg(self): 
5033          return self.__field_is_txt_msg.getvalue() 
5034   
5035 -    def __setfield_is_txt_msg(self, value): 
5036          if isinstance(value,pBOOL): 
5037              self.__field_is_txt_msg=value 
5038          else: 
5039              self.__field_is_txt_msg=pBOOL(value,**{ 'value': self.file_type==SMS_TXT_TYPE and self.msg_type in SMS_VALID_TYPE }) 
5040   
5041 -    def __delfield_is_txt_msg(self): del self.__field_is_txt_msg 
5042   
5043      is_txt_msg=property(__getfield_is_txt_msg, __setfield_is_txt_msg, __delfield_is_txt_msg, None) 
5044   
5045 -    def __getfield_in_msg(self): 
5046          return self.__field_in_msg.getvalue() 
5047   
5048 -    def __setfield_in_msg(self, value): 
5049          if isinstance(value,pBOOL): 
5050              self.__field_in_msg=value 
5051          else: 
5052              self.__field_in_msg=pBOOL(value,**{ 'value': self.msg_type==SMS_TYPE_IN }) 
5053   
5054 -    def __delfield_in_msg(self): del self.__field_in_msg 
5055   
5056      in_msg=property(__getfield_in_msg, __setfield_in_msg, __delfield_in_msg, None) 
5057   
5058 -    def __getfield_sent_msg(self): 
5059          return self.__field_sent_msg.getvalue() 
5060   
5061 -    def __setfield_sent_msg(self, value): 
5062          if isinstance(value,pBOOL): 
5063              self.__field_sent_msg=value 
5064          else: 
5065              self.__field_sent_msg=pBOOL(value,**{ 'value': self.msg_type==SMS_TYPE_SENT }) 
5066   
5067 -    def __delfield_sent_msg(self): del self.__field_sent_msg 
5068   
5069      sent_msg=property(__getfield_sent_msg, __setfield_sent_msg, __delfield_sent_msg, None) 
5070   
5071 -    def __getfield_draft_msg(self): 
5072          return self.__field_draft_msg.getvalue() 
5073   
5074 -    def __setfield_draft_msg(self, value): 
5075          if isinstance(value,pBOOL): 
5076              self.__field_draft_msg=value 
5077          else: 
5078              self.__field_draft_msg=pBOOL(value,**{ 'value': self.msg_type==SMS_TYPE_DRAFT }) 
5079   
5080 -    def __delfield_draft_msg(self): del self.__field_draft_msg 
5081   
5082      draft_msg=property(__getfield_draft_msg, __setfield_draft_msg, __delfield_draft_msg, None) 
5083   
5084 -    def __getfield_body(self): 
5085          return self.__field_body.getvalue() 
5086   
5087 -    def __setfield_body(self, value): 
5088          if isinstance(value,sms_body): 
5089              self.__field_body=value 
5090          else: 
5091              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) or (not self.bitmap2),            'has_1byte2': self.bitmap2 & SMS_FLG2_MSG,            'has_40bytes': self.bitmap1 & SMS_FLG1_HAS40 }) 
5092   
5093 -    def __delfield_body(self): del self.__field_body 
5094   
5095      body=property(__getfield_body, __setfield_body, __delfield_body, None) 
5096   
5097 -    def iscontainer(self): 
5098          return True 
5099   
5100 -    def containerelements(self): 
5101          yield ('index', self.__field_index, None) 
5102          yield ('msg_len', self.__field_msg_len, None) 
5103          yield ('callback_len', self.__field_callback_len, None) 
5104          yield ('bitmap1', self.__field_bitmap1, None) 
5105          yield ('bitmap2', self.__field_bitmap2, None) 
5106          yield ('body_len', self.__field_body_len, None) 
5107          yield ('file_type', self.__field_file_type, None) 
5108          yield ('msg_type', self.__field_msg_type, None) 
5109          yield ('enhance_delivery', self.__field_enhance_delivery, None) 
5110          yield ('is_txt_msg', self.__field_is_txt_msg, None) 
5111          yield ('in_msg', self.__field_in_msg, None) 
5112          yield ('sent_msg', self.__field_sent_msg, None) 
5113          yield ('draft_msg', self.__field_draft_msg, None) 
5114          if self.is_txt_msg.value: 
5115              yield ('body', self.__field_body, None) 
5116   
5117   
5118   
5119   
5120 -class sms_msg_stat_list(BaseProtogenClass): 
5121      # Read-From-Buffer-Only Class 
5122      __fields=['status'] 
5123   
5124 -    def __init__(self, *args, **kwargs): 
5125          dict={} 
5126          # What was supplied to this function 
5127          dict.update(kwargs) 
5128          # Parent constructor 
5129          super(sms_msg_stat_list,self).__init__(**dict) 
5130          if self.__class__ is sms_msg_stat_list: 
5131              self._update(args,dict) 
5132   
5133   
5134 -    def getfields(self): 
5135          return self.__fields 
5136   
5137   
5138 -    def _update(self, args, kwargs): 
5139          super(sms_msg_stat_list,self)._update(args,kwargs) 
5140          keys=kwargs.keys() 
5141          for key in keys: 
5142              if key in self.__fields: 
5143                  setattr(self, key, kwargs[key]) 
5144                  del kwargs[key] 
5145          # Were any unrecognized kwargs passed in? 
5146          if __debug__: 
5147              self._complainaboutunusedargs(sms_msg_stat_list,kwargs) 
5148          if len(args): 
5149              dict2={'sizeinbytes': 1} 
5150              dict2.update(kwargs) 
5151              kwargs=dict2 
5152              self.__field_status=UINT(*args,**dict2) 
5153          # Make all P fields that haven't already been constructed 
5154   
5155   
5156 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
5157          'Writes this packet to the supplied buffer' 
5158          raise NotImplementedError 
5159   
5160   
5161 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
5162          'Reads this packet from the supplied buffer' 
5163          self._bufferstartoffset=buf.getcurrentoffset() 
5164          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
5165          self.__field_status=UINT(**{'sizeinbytes': 1}) 
5166          self.__field_status.readfrombuffer(buf) 
5167          self._bufferendoffset=buf.getcurrentoffset() 
5168   
5169   
5170 -    def __getfield_status(self): 
5171          return self.__field_status.getvalue() 
5172   
5173 -    def __setfield_status(self, value): 
5174          if isinstance(value,UINT): 
5175              self.__field_status=value 
5176          else: 
5177              self.__field_status=UINT(value,**{'sizeinbytes': 1}) 
5178   
5179 -    def __delfield_status(self): del self.__field_status 
5180   
5181      status=property(__getfield_status, __setfield_status, __delfield_status, None) 
5182   
5183 -    def iscontainer(self): 
5184          return True 
5185   
5186 -    def containerelements(self): 
5187          yield ('status', self.__field_status, None) 
5188   
5189   
5190   
5191   
5192 -class sms_datetime_list(BaseProtogenClass): 
5193      # Read-From-Buffer-Only Class 
5194      __fields=['datetime'] 
5195   
5196 -    def __init__(self, *args, **kwargs): 
5197          dict={} 
5198          # What was supplied to this function 
5199          dict.update(kwargs) 
5200          # Parent constructor 
5201          super(sms_datetime_list,self).__init__(**dict) 
5202          if self.__class__ is sms_datetime_list: 
5203              self._update(args,dict) 
5204   
5205   
5206 -    def getfields(self): 
5207          return self.__fields 
5208   
5209   
5210 -    def _update(self, args, kwargs): 
5211          super(sms_datetime_list,self)._update(args,kwargs) 
5212          keys=kwargs.keys() 
5213          for key in keys: 
5214              if key in self.__fields: 
5215                  setattr(self, key, kwargs[key]) 
5216                  del kwargs[key] 
5217          # Were any unrecognized kwargs passed in? 
5218          if __debug__: 
5219              self._complainaboutunusedargs(sms_datetime_list,kwargs) 
5220          if len(args): 
5221              dict2={'sizeinbytes': 4} 
5222              dict2.update(kwargs) 
5223              kwargs=dict2 
5224              self.__field_datetime=DateTime2(*args,**dict2) 
5225          # Make all P fields that haven't already been constructed 
5226   
5227   
5228 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
5229          'Writes this packet to the supplied buffer' 
5230          raise NotImplementedError 
5231   
5232   
5233 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
5234          'Reads this packet from the supplied buffer' 
5235          self._bufferstartoffset=buf.getcurrentoffset() 
5236          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
5237          self.__field_datetime=DateTime2(**{'sizeinbytes': 4}) 
5238          self.__field_datetime.readfrombuffer(buf) 
5239          self._bufferendoffset=buf.getcurrentoffset() 
5240   
5241   
5242 -    def __getfield_datetime(self): 
5243          return self.__field_datetime.getvalue() 
5244   
5245 -    def __setfield_datetime(self, value): 
5246          if isinstance(value,DateTime2): 
5247              self.__field_datetime=value 
5248          else: 
5249              self.__field_datetime=DateTime2(value,**{'sizeinbytes': 4}) 
5250   
5251 -    def __delfield_datetime(self): del self.__field_datetime 
5252   
5253      datetime=property(__getfield_datetime, __setfield_datetime, __delfield_datetime, None) 
5254   
5255 -    def iscontainer(self): 
5256          return True 
5257   
5258 -    def containerelements(self): 
5259          yield ('datetime', self.__field_datetime, None) 
5260   
5261   
5262   
5263   
5264 -class sms_delivered_datetime(BaseProtogenClass): 
5265      # Read-From-Buffer-Only Class 
5266      __fields=['datetime'] 
5267   
5268 -    def __init__(self, *args, **kwargs): 
5269          dict={} 
5270          # What was supplied to this function 
5271          dict.update(kwargs) 
5272          # Parent constructor 
5273          super(sms_delivered_datetime,self).__init__(**dict) 
5274          if self.__class__ is sms_delivered_datetime: 
5275              self._update(args,dict) 
5276   
5277   
5278 -    def getfields(self): 
5279          return self.__fields 
5280   
5281   
5282 -    def _update(self, args, kwargs): 
5283          super(sms_delivered_datetime,self)._update(args,kwargs) 
5284          keys=kwargs.keys() 
5285          for key in keys: 
5286              if key in self.__fields: 
5287                  setattr(self, key, kwargs[key]) 
5288                  del kwargs[key] 
5289          # Were any unrecognized kwargs passed in? 
5290          if __debug__: 
5291              self._complainaboutunusedargs(sms_delivered_datetime,kwargs) 
5292          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
5293          # Make all P fields that haven't already been constructed 
5294   
5295   
5296 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
5297          'Writes this packet to the supplied buffer' 
5298          raise NotImplementedError 
5299   
5300   
5301 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
5302          'Reads this packet from the supplied buffer' 
5303          self._bufferstartoffset=buf.getcurrentoffset() 
5304          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
5305          self.__field_datetime=LIST(**{ 'elementclass': sms_datetime_list,             'length': 10 }) 
5306          self.__field_datetime.readfrombuffer(buf) 
5307          DONTCARE(**{'sizeinbytes': 20}).readfrombuffer(buf) 
5308          self._bufferendoffset=buf.getcurrentoffset() 
5309   
5310   
5311 -    def __getfield_datetime(self): 
5312          return self.__field_datetime.getvalue() 
5313   
5314 -    def __setfield_datetime(self, value): 
5315          if isinstance(value,LIST): 
5316              self.__field_datetime=value 
5317          else: 
5318              self.__field_datetime=LIST(value,**{ 'elementclass': sms_datetime_list,             'length': 10 }) 
5319   
5320 -    def __delfield_datetime(self): del self.__field_datetime 
5321   
5322      datetime=property(__getfield_datetime, __setfield_datetime, __delfield_datetime, None) 
5323   
5324 -    def iscontainer(self): 
5325          return True 
5326   
5327 -    def containerelements(self): 
5328          yield ('datetime', self.__field_datetime, None) 
5329   
5330   
5331   
5332   
5333 -class sms_body(BaseProtogenClass): 
5334      # Read-From-Buffer-Only Class 
5335      __fields=['msg_len', 'has_callback', 'has_priority', 'has_1byte', 'has_1byte2', 'has_40bytes', 'msg', 'msg', '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'] 
5336   
5337 -    def __init__(self, *args, **kwargs): 
5338          dict={} 
5339          # What was supplied to this function 
5340          dict.update(kwargs) 
5341          # Parent constructor 
5342          super(sms_body,self).__init__(**dict) 
5343          if self.__class__ is sms_body: 
5344              self._update(args,dict) 
5345   
5346   
5347 -    def getfields(self): 
5348          return self.__fields 
5349   
5350   
5351 -    def _update(self, args, kwargs): 
5352          super(sms_body,self)._update(args,kwargs) 
5353          keys=kwargs.keys() 
5354          for key in keys: 
5355              if key in self.__fields: 
5356                  setattr(self, key, kwargs[key]) 
5357                  del kwargs[key] 
5358          # Were any unrecognized kwargs passed in? 
5359          if __debug__: 
5360              self._complainaboutunusedargs(sms_body,kwargs) 
5361          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
5362          # Make all P fields that haven't already been constructed 
5363          try: self.__field_msg_len 
5364          except: 
5365              self.__field_msg_len=UINT() 
5366          try: self.__field_has_callback 
5367          except: 
5368              self.__field_has_callback=BOOL(**{ 'default': True }) 
5369          try: self.__field_has_priority 
5370          except: 
5371              self.__field_has_priority=BOOL(**{ 'default': False }) 
5372          try: self.__field_has_1byte 
5373          except: 
5374              self.__field_has_1byte=BOOL(**{ 'default': False }) 
5375          try: self.__field_has_1byte2 
5376          except: 
5377              self.__field_has_1byte2=BOOL(**{ 'default': True }) 
5378          try: self.__field_has_40bytes 
5379          except: 
5380              self.__field_has_40bytes=BOOL(**{ 'default': False }) 
5381          try: self.__field_msg 
5382          except: 
5383              self.__field_msg=USTRING(**{'default': '' }) 
5384   
5385   
5386 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
5387          'Writes this packet to the supplied buffer' 
5388          raise NotImplementedError 
5389   
5390   
5391 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
5392          'Reads this packet from the supplied buffer' 
5393          self._bufferstartoffset=buf.getcurrentoffset() 
5394          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
5395          if self.msg_len: 
5396              DONTCARE(**{'sizeinbytes': 54}).readfrombuffer(buf) 
5397              self.__field_msg=USTRING(**{ 'sizeinbytes': self.msg_len,                    'encoding': ENCODING,                    'terminator': None }) 
5398              self.__field_msg.readfrombuffer(buf) 
5399          else: 
5400              DONTCARE(**{'sizeinbytes': 53}).readfrombuffer(buf) 
5401          if self.has_callback: 
5402              DONTCARE(**{'sizeinbytes': 4}).readfrombuffer(buf) 
5403              self.__field_callback_len=UINT(**{'sizeinbytes': 1}) 
5404              self.__field_callback_len.readfrombuffer(buf) 
5405              self.__field_callback=STRING(**{ 'sizeinbytes': self.callback_len,                   'terminator': None }) 
5406              self.__field_callback.readfrombuffer(buf) 
5407          if self.has_priority: 
5408              self.__field_priority=UINT(**{'sizeinbytes': 1}) 
5409              self.__field_priority.readfrombuffer(buf) 
5410          if self.has_1byte: 
5411              DONTCARE(**{'sizeinbytes': 1}).readfrombuffer(buf) 
5412          DONTCARE(**{'sizeinbytes': 40}).readfrombuffer(buf) 
5413          self.__field_datetime=DateTime1(**{'sizeinbytes': 4}) 
5414          self.__field_datetime.readfrombuffer(buf) 
5415          DONTCARE(**{'sizeinbytes': 13}).readfrombuffer(buf) 
5416          self.__field_addr_len0=UINT(**{'sizeinbytes': 1}) 
5417          self.__field_addr_len0.readfrombuffer(buf) 
5418          self.__field_addr_len1=UINT(**{'sizeinbytes': 1}) 
5419          self.__field_addr_len1.readfrombuffer(buf) 
5420          self.__field_addr_len2=UINT(**{'sizeinbytes': 1}) 
5421          self.__field_addr_len2.readfrombuffer(buf) 
5422          self.__field_addr_len3=UINT(**{'sizeinbytes': 1}) 
5423          self.__field_addr_len3.readfrombuffer(buf) 
5424          self.__field_addr_len4=UINT(**{'sizeinbytes': 1}) 
5425          self.__field_addr_len4.readfrombuffer(buf) 
5426          self.__field_addr_len5=UINT(**{'sizeinbytes': 1}) 
5427          self.__field_addr_len5.readfrombuffer(buf) 
5428          self.__field_addr_len6=UINT(**{'sizeinbytes': 1}) 
5429          self.__field_addr_len6.readfrombuffer(buf) 
5430          self.__field_addr_len7=UINT(**{'sizeinbytes': 1}) 
5431          self.__field_addr_len7.readfrombuffer(buf) 
5432          self.__field_addr_len8=UINT(**{'sizeinbytes': 1}) 
5433          self.__field_addr_len8.readfrombuffer(buf) 
5434          self.__field_addr_len9=UINT(**{'sizeinbytes': 1}) 
5435          self.__field_addr_len9.readfrombuffer(buf) 
5436          if self.addr_len0: 
5437              self.__field_addr0=STRING(**{ 'sizeinbytes': self.addr_len0,                   'terminator': None }) 
5438              self.__field_addr0.readfrombuffer(buf) 
5439          if self.addr_len1: 
5440              self.__field_addr1=STRING(**{ 'sizeinbytes': self.addr_len1,                   'terminator': None }) 
5441              self.__field_addr1.readfrombuffer(buf) 
5442          if self.addr_len2: 
5443              self.__field_addr2=STRING(**{ 'sizeinbytes': self.addr_len2,                   'terminator': None }) 
5444              self.__field_addr2.readfrombuffer(buf) 
5445          if self.addr_len3: 
5446              self.__field_addr3=STRING(**{ 'sizeinbytes': self.addr_len3,                   'terminator': None }) 
5447              self.__field_addr3.readfrombuffer(buf) 
5448          if self.addr_len4: 
5449              self.__field_addr4=STRING(**{ 'sizeinbytes': self.addr_len4,                   'terminator': None }) 
5450              self.__field_addr4.readfrombuffer(buf) 
5451          if self.addr_len5: 
5452              self.__field_addr5=STRING(**{ 'sizeinbytes': self.addr_len5,                   'terminator': None }) 
5453              self.__field_addr5.readfrombuffer(buf) 
5454          if self.addr_len6: 
5455              self.__field_addr6=STRING(**{ 'sizeinbytes': self.addr_len6,                   'terminator': None }) 
5456              self.__field_addr6.readfrombuffer(buf) 
5457          if self.addr_len7: 
5458              self.__field_addr7=STRING(**{ 'sizeinbytes': self.addr_len7,                   'terminator': None }) 
5459              self.__field_addr7.readfrombuffer(buf) 
5460          if self.addr_len8: 
5461              self.__field_addr8=STRING(**{ 'sizeinbytes': self.addr_len8,                   'terminator': None }) 
5462              self.__field_addr8.readfrombuffer(buf) 
5463          if self.addr_len9: 
5464              self.__field_addr9=STRING(**{ 'sizeinbytes': self.addr_len9,                   'terminator': None }) 
5465              self.__field_addr9.readfrombuffer(buf) 
5466          if not self.has_1byte and self.has_1byte2: 
5467              DONTCARE(**{'sizeinbytes': 1}).readfrombuffer(buf) 
5468          if self.has_1byte2: 
5469              DONTCARE(**{'sizeinbytes': 1}).readfrombuffer(buf) 
5470          DONTCARE(**{'sizeinbytes': 81}).readfrombuffer(buf) 
5471          if self.has_40bytes: 
5472              DONTCARE(**{'sizeinbytes': 40}).readfrombuffer(buf) 
5473          self.__field_msg_stat=LIST(**{ 'elementclass': sms_msg_stat_list,             'length': 10 }) 
5474          self.__field_msg_stat.readfrombuffer(buf) 
5475          self._bufferendoffset=buf.getcurrentoffset() 
5476   
5477   
5478 -    def __getfield_msg_len(self): 
5479          return self.__field_msg_len.getvalue() 
5480   
5481 -    def __setfield_msg_len(self, value): 
5482          if isinstance(value,UINT): 
5483              self.__field_msg_len=value 
5484          else: 
5485              self.__field_msg_len=UINT(value,) 
5486   
5487 -    def __delfield_msg_len(self): del self.__field_msg_len 
5488   
5489      msg_len=property(__getfield_msg_len, __setfield_msg_len, __delfield_msg_len, None) 
5490   
5491 -    def __getfield_has_callback(self): 
5492          try: self.__field_has_callback 
5493          except: 
5494              self.__field_has_callback=BOOL(**{ 'default': True }) 
5495          return self.__field_has_callback.getvalue() 
5496   
5497 -    def __setfield_has_callback(self, value): 
5498          if isinstance(value,BOOL): 
5499              self.__field_has_callback=value 
5500          else: 
5501              self.__field_has_callback=BOOL(value,**{ 'default': True }) 
5502   
5503 -    def __delfield_has_callback(self): del self.__field_has_callback 
5504   
5505      has_callback=property(__getfield_has_callback, __setfield_has_callback, __delfield_has_callback, None) 
5506   
5507 -    def __getfield_has_priority(self): 
5508          try: self.__field_has_priority 
5509          except: 
5510              self.__field_has_priority=BOOL(**{ 'default': False }) 
5511          return self.__field_has_priority.getvalue() 
5512   
5513 -    def __setfield_has_priority(self, value): 
5514          if isinstance(value,BOOL): 
5515              self.__field_has_priority=value 
5516          else: 
5517              self.__field_has_priority=BOOL(value,**{ 'default': False }) 
5518   
5519 -    def __delfield_has_priority(self): del self.__field_has_priority 
5520   
5521      has_priority=property(__getfield_has_priority, __setfield_has_priority, __delfield_has_priority, None) 
5522   
5523 -    def __getfield_has_1byte(self): 
5524          try: self.__field_has_1byte 
5525          except: 
5526              self.__field_has_1byte=BOOL(**{ 'default': False }) 
5527          return self.__field_has_1byte.getvalue() 
5528   
5529 -    def __setfield_has_1byte(self, value): 
5530          if isinstance(value,BOOL): 
5531              self.__field_has_1byte=value 
5532          else: 
5533              self.__field_has_1byte=BOOL(value,**{ 'default': False }) 
5534   
5535 -    def __delfield_has_1byte(self): del self.__field_has_1byte 
5536   
5537      has_1byte=property(__getfield_has_1byte, __setfield_has_1byte, __delfield_has_1byte, None) 
5538   
5539 -    def __getfield_has_1byte2(self): 
5540          try: self.__field_has_1byte2 
5541          except: 
5542              self.__field_has_1byte2=BOOL(**{ 'default': True }) 
5543          return self.__field_has_1byte2.getvalue() 
5544   
5545 -    def __setfield_has_1byte2(self, value): 
5546          if isinstance(value,BOOL): 
5547              self.__field_has_1byte2=value 
5548          else: 
5549              self.__field_has_1byte2=BOOL(value,**{ 'default': True }) 
5550   
5551 -    def __delfield_has_1byte2(self): del self.__field_has_1byte2 
5552   
5553      has_1byte2=property(__getfield_has_1byte2, __setfield_has_1byte2, __delfield_has_1byte2, None) 
5554   
5555 -    def __getfield_has_40bytes(self): 
5556          try: self.__field_has_40bytes 
5557          except: 
5558              self.__field_has_40bytes=BOOL(**{ 'default': False }) 
5559          return self.__field_has_40bytes.getvalue() 
5560   
5561 -    def __setfield_has_40bytes(self, value): 
5562          if isinstance(value,BOOL): 
5563              self.__field_has_40bytes=value 
5564          else: 
5565              self.__field_has_40bytes=BOOL(value,**{ 'default': False }) 
5566   
5567 -    def __delfield_has_40bytes(self): del self.__field_has_40bytes 
5568   
5569      has_40bytes=property(__getfield_has_40bytes, __setfield_has_40bytes, __delfield_has_40bytes, None) 
5570   
5571 -    def __getfield_msg(self): 
5572          return self.__field_msg.getvalue() 
5573   
5574 -    def __setfield_msg(self, value): 
5575          if isinstance(value,USTRING): 
5576              self.__field_msg=value 
5577          else: 
5578              self.__field_msg=USTRING(value,**{ 'sizeinbytes': self.msg_len,                    'encoding': ENCODING,                    'terminator': None }) 
5579   
5580 -    def __delfield_msg(self): del self.__field_msg 
5581   
5582      msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None) 
5583   
5584 -    def __getfield_msg(self): 
5585          try: self.__field_msg 
5586          except: 
5587              self.__field_msg=USTRING(**{'default': '' }) 
5588          return self.__field_msg.getvalue() 
5589   
5590 -    def __setfield_msg(self, value): 
5591          if isinstance(value,USTRING): 
5592              self.__field_msg=value 
5593          else: 
5594              self.__field_msg=USTRING(value,**{'default': '' }) 
5595   
5596 -    def __delfield_msg(self): del self.__field_msg 
5597   
5598      msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None) 
5599   
5600 -    def __getfield_callback_len(self): 
5601          return self.__field_callback_len.getvalue() 
5602   
5603 -    def __setfield_callback_len(self, value): 
5604          if isinstance(value,UINT): 
5605              self.__field_callback_len=value 
5606          else: 
5607              self.__field_callback_len=UINT(value,**{'sizeinbytes': 1}) 
5608   
5609 -    def __delfield_callback_len(self): del self.__field_callback_len 
5610   
5611      callback_len=property(__getfield_callback_len, __setfield_callback_len, __delfield_callback_len, None) 
5612   
5613 -    def __getfield_callback(self): 
5614          return self.__field_callback.getvalue() 
5615   
5616 -    def __setfield_callback(self, value): 
5617          if isinstance(value,STRING): 
5618              self.__field_callback=value 
5619          else: 
5620              self.__field_callback=STRING(value,**{ 'sizeinbytes': self.callback_len,                   'terminator': None }) 
5621   
5622 -    def __delfield_callback(self): del self.__field_callback 
5623   
5624      callback=property(__getfield_callback, __setfield_callback, __delfield_callback, None) 
5625   
5626 -    def __getfield_priority(self): 
5627          return self.__field_priority.getvalue() 
5628   
5629 -    def __setfield_priority(self, value): 
5630          if isinstance(value,UINT): 
5631              self.__field_priority=value 
5632          else: 
5633              self.__field_priority=UINT(value,**{'sizeinbytes': 1}) 
5634   
5635 -    def __delfield_priority(self): del self.__field_priority 
5636   
5637      priority=property(__getfield_priority, __setfield_priority, __delfield_priority, None) 
5638   
5639 -    def __getfield_datetime(self): 
5640          return self.__field_datetime.getvalue() 
5641   
5642 -    def __setfield_datetime(self, value): 
5643          if isinstance(value,DateTime1): 
5644              self.__field_datetime=value 
5645          else: 
5646              self.__field_datetime=DateTime1(value,**{'sizeinbytes': 4}) 
5647   
5648 -    def __delfield_datetime(self): del self.__field_datetime 
5649   
5650      datetime=property(__getfield_datetime, __setfield_datetime, __delfield_datetime, None) 
5651   
5652 -    def __getfield_addr_len0(self): 
5653          return self.__field_addr_len0.getvalue() 
5654   
5655 -    def __setfield_addr_len0(self, value): 
5656          if isinstance(value,UINT): 
5657              self.__field_addr_len0=value 
5658          else: 
5659              self.__field_addr_len0=UINT(value,**{'sizeinbytes': 1}) 
5660   
5661 -    def __delfield_addr_len0(self): del self.__field_addr_len0 
5662   
5663      addr_len0=property(__getfield_addr_len0, __setfield_addr_len0, __delfield_addr_len0, None) 
5664   
5665 -    def __getfield_addr_len1(self): 
5666          return self.__field_addr_len1.getvalue() 
5667   
5668 -    def __setfield_addr_len1(self, value): 
5669          if isinstance(value,UINT): 
5670              self.__field_addr_len1=value 
5671          else: 
5672              self.__field_addr_len1=UINT(value,**{'sizeinbytes': 1}) 
5673   
5674 -    def __delfield_addr_len1(self): del self.__field_addr_len1 
5675   
5676      addr_len1=property(__getfield_addr_len1, __setfield_addr_len1, __delfield_addr_len1, None) 
5677   
5678 -    def __getfield_addr_len2(self): 
5679          return self.__field_addr_len2.getvalue() 
5680   
5681 -    def __setfield_addr_len2(self, value): 
5682          if isinstance(value,UINT): 
5683              self.__field_addr_len2=value 
5684          else: 
5685              self.__field_addr_len2=UINT(value,**{'sizeinbytes': 1}) 
5686   
5687 -    def __delfield_addr_len2(self): del self.__field_addr_len2 
5688   
5689      addr_len2=property(__getfield_addr_len2, __setfield_addr_len2, __delfield_addr_len2, None) 
5690   
5691 -    def __getfield_addr_len3(self): 
5692          return self.__field_addr_len3.getvalue() 
5693   
5694 -    def __setfield_addr_len3(self, value): 
5695          if isinstance(value,UINT): 
5696              self.__field_addr_len3=value 
5697          else: 
5698              self.__field_addr_len3=UINT(value,**{'sizeinbytes': 1}) 
5699   
5700 -    def __delfield_addr_len3(self): del self.__field_addr_len3 
5701   
5702      addr_len3=property(__getfield_addr_len3, __setfield_addr_len3, __delfield_addr_len3, None) 
5703   
5704 -    def __getfield_addr_len4(self): 
5705          return self.__field_addr_len4.getvalue() 
5706   
5707 -    def __setfield_addr_len4(self, value): 
5708          if isinstance(value,UINT): 
5709              self.__field_addr_len4=value 
5710          else: 
5711              self.__field_addr_len4=UINT(value,**{'sizeinbytes': 1}) 
5712   
5713 -    def __delfield_addr_len4(self): del self.__field_addr_len4 
5714   
5715      addr_len4=property(__getfield_addr_len4, __setfield_addr_len4, __delfield_addr_len4, None) 
5716   
5717 -    def __getfield_addr_len5(self): 
5718          return self.__field_addr_len5.getvalue() 
5719   
5720 -    def __setfield_addr_len5(self, value): 
5721          if isinstance(value,UINT): 
5722              self.__field_addr_len5=value 
5723          else: 
5724              self.__field_addr_len5=UINT(value,**{'sizeinbytes': 1}) 
5725   
5726 -    def __delfield_addr_len5(self): del self.__field_addr_len5 
5727   
5728      addr_len5=property(__getfield_addr_len5, __setfield_addr_len5, __delfield_addr_len5, None) 
5729   
5730 -    def __getfield_addr_len6(self): 
5731          return self.__field_addr_len6.getvalue() 
5732   
5733 -    def __setfield_addr_len6(self, value): 
5734          if isinstance(value,UINT): 
5735              self.__field_addr_len6=value 
5736          else: 
5737              self.__field_addr_len6=UINT(value,**{'sizeinbytes': 1}) 
5738   
5739 -    def __delfield_addr_len6(self): del self.__field_addr_len6 
5740   
5741      addr_len6=property(__getfield_addr_len6, __setfield_addr_len6, __delfield_addr_len6, None) 
5742   
5743 -    def __getfield_addr_len7(self): 
5744          return self.__field_addr_len7.getvalue() 
5745   
5746 -    def __setfield_addr_len7(self, value): 
5747          if isinstance(value,UINT): 
5748              self.__field_addr_len7=value 
5749          else: 
5750              self.__field_addr_len7=UINT(value,**{'sizeinbytes': 1}) 
5751   
5752 -    def __delfield_addr_len7(self): del self.__field_addr_len7 
5753   
5754      addr_len7=property(__getfield_addr_len7, __setfield_addr_len7, __delfield_addr_len7, None) 
5755   
5756 -    def __getfield_addr_len8(self): 
5757          return self.__field_addr_len8.getvalue() 
5758   
5759 -    def __setfield_addr_len8(self, value): 
5760          if isinstance(value,UINT): 
5761              self.__field_addr_len8=value 
5762          else: 
5763              self.__field_addr_len8=UINT(value,**{'sizeinbytes': 1}) 
5764   
5765 -    def __delfield_addr_len8(self): del self.__field_addr_len8 
5766   
5767      addr_len8=property(__getfield_addr_len8, __setfield_addr_len8, __delfield_addr_len8, None) 
5768   
5769 -    def __getfield_addr_len9(self): 
5770          return self.__field_addr_len9.getvalue() 
5771   
5772 -    def __setfield_addr_len9(self, value): 
5773          if isinstance(value,UINT): 
5774              self.__field_addr_len9=value 
5775          else: 
5776              self.__field_addr_len9=UINT(value,**{'sizeinbytes': 1}) 
5777   
5778 -    def __delfield_addr_len9(self): del self.__field_addr_len9 
5779   
5780      addr_len9=property(__getfield_addr_len9, __setfield_addr_len9, __delfield_addr_len9, None) 
5781   
5782 -    def __getfield_addr0(self): 
5783          return self.__field_addr0.getvalue() 
5784   
5785 -    def __setfield_addr0(self, value): 
5786          if isinstance(value,STRING): 
5787              self.__field_addr0=value 
5788          else: 
5789              self.__field_addr0=STRING(value,**{ 'sizeinbytes': self.addr_len0,                   'terminator': None }) 
5790   
5791 -    def __delfield_addr0(self): del self.__field_addr0 
5792   
5793      addr0=property(__getfield_addr0, __setfield_addr0, __delfield_addr0, None) 
5794   
5795 -    def __getfield_addr1(self): 
5796          return self.__field_addr1.getvalue() 
5797   
5798 -    def __setfield_addr1(self, value): 
5799          if isinstance(value,STRING): 
5800              self.__field_addr1=value 
5801          else: 
5802              self.__field_addr1=STRING(value,**{ 'sizeinbytes': self.addr_len1,                   'terminator': None }) 
5803   
5804 -    def __delfield_addr1(self): del self.__field_addr1 
5805   
5806      addr1=property(__getfield_addr1, __setfield_addr1, __delfield_addr1, None) 
5807   
5808 -    def __getfield_addr2(self): 
5809          return self.__field_addr2.getvalue() 
5810   
5811 -    def __setfield_addr2(self, value): 
5812          if isinstance(value,STRING): 
5813              self.__field_addr2=value 
5814          else: 
5815              self.__field_addr2=STRING(value,**{ 'sizeinbytes': self.addr_len2,                   'terminator': None }) 
5816   
5817 -    def __delfield_addr2(self): del self.__field_addr2 
5818   
5819      addr2=property(__getfield_addr2, __setfield_addr2, __delfield_addr2, None) 
5820   
5821 -    def __getfield_addr3(self): 
5822          return self.__field_addr3.getvalue() 
5823   
5824 -    def __setfield_addr3(self, value): 
5825          if isinstance(value,STRING): 
5826              self.__field_addr3=value 
5827          else: 
5828              self.__field_addr3=STRING(value,**{ 'sizeinbytes': self.addr_len3,                   'terminator': None }) 
5829   
5830 -    def __delfield_addr3(self): del self.__field_addr3 
5831   
5832      addr3=property(__getfield_addr3, __setfield_addr3, __delfield_addr3, None) 
5833   
5834 -    def __getfield_addr4(self): 
5835          return self.__field_addr4.getvalue() 
5836   
5837 -    def __setfield_addr4(self, value): 
5838          if isinstance(value,STRING): 
5839              self.__field_addr4=value 
5840          else: 
5841              self.__field_addr4=STRING(value,**{ 'sizeinbytes': self.addr_len4,                   'terminator': None }) 
5842   
5843 -    def __delfield_addr4(self): del self.__field_addr4 
5844   
5845      addr4=property(__getfield_addr4, __setfield_addr4, __delfield_addr4, None) 
5846   
5847 -    def __getfield_addr5(self): 
5848          return self.__field_addr5.getvalue() 
5849   
5850 -    def __setfield_addr5(self, value): 
5851          if isinstance(value,STRING): 
5852              self.__field_addr5=value 
5853          else: 
5854              self.__field_addr5=STRING(value,**{ 'sizeinbytes': self.addr_len5,                   'terminator': None }) 
5855   
5856 -    def __delfield_addr5(self): del self.__field_addr5 
5857   
5858      addr5=property(__getfield_addr5, __setfield_addr5, __delfield_addr5, None) 
5859   
5860 -    def __getfield_addr6(self): 
5861          return self.__field_addr6.getvalue() 
5862   
5863 -    def __setfield_addr6(self, value): 
5864          if isinstance(value,STRING): 
5865              self.__field_addr6=value 
5866          else: 
5867              self.__field_addr6=STRING(value,**{ 'sizeinbytes': self.addr_len6,                   'terminator': None }) 
5868   
5869 -    def __delfield_addr6(self): del self.__field_addr6 
5870   
5871      addr6=property(__getfield_addr6, __setfield_addr6, __delfield_addr6, None) 
5872   
5873 -    def __getfield_addr7(self): 
5874          return self.__field_addr7.getvalue() 
5875   
5876 -    def __setfield_addr7(self, value): 
5877          if isinstance(value,STRING): 
5878              self.__field_addr7=value 
5879          else: 
5880              self.__field_addr7=STRING(value,**{ 'sizeinbytes': self.addr_len7,                   'terminator': None }) 
5881   
5882 -    def __delfield_addr7(self): del self.__field_addr7 
5883   
5884      addr7=property(__getfield_addr7, __setfield_addr7, __delfield_addr7, None) 
5885   
5886 -    def __getfield_addr8(self): 
5887          return self.__field_addr8.getvalue() 
5888   
5889 -    def __setfield_addr8(self, value): 
5890          if isinstance(value,STRING): 
5891              self.__field_addr8=value 
5892          else: 
5893              self.__field_addr8=STRING(value,**{ 'sizeinbytes': self.addr_len8,                   'terminator': None }) 
5894   
5895 -    def __delfield_addr8(self): del self.__field_addr8 
5896   
5897      addr8=property(__getfield_addr8, __setfield_addr8, __delfield_addr8, None) 
5898   
5899 -    def __getfield_addr9(self): 
5900          return self.__field_addr9.getvalue() 
5901   
5902 -    def __setfield_addr9(self, value): 
5903          if isinstance(value,STRING): 
5904              self.__field_addr9=value 
5905          else: 
5906              self.__field_addr9=STRING(value,**{ 'sizeinbytes': self.addr_len9,                   'terminator': None }) 
5907   
5908 -    def __delfield_addr9(self): del self.__field_addr9 
5909   
5910      addr9=property(__getfield_addr9, __setfield_addr9, __delfield_addr9, None) 
5911   
5912 -    def __getfield_msg_stat(self): 
5913          return self.__field_msg_stat.getvalue() 
5914   
5915 -    def __setfield_msg_stat(self, value): 
5916          if isinstance(value,LIST): 
5917              self.__field_msg_stat=value 
5918          else: 
5919              self.__field_msg_stat=LIST(value,**{ 'elementclass': sms_msg_stat_list,             'length': 10 }) 
5920   
5921 -    def __delfield_msg_stat(self): del self.__field_msg_stat 
5922   
5923      msg_stat=property(__getfield_msg_stat, __setfield_msg_stat, __delfield_msg_stat, None) 
5924   
5925 -    def iscontainer(self): 
5926          return True 
5927   
5928 -    def containerelements(self): 
5929          yield ('msg_len', self.__field_msg_len, None) 
5930          yield ('has_callback', self.__field_has_callback, None) 
5931          yield ('has_priority', self.__field_has_priority, None) 
5932          yield ('has_1byte', self.__field_has_1byte, None) 
5933          yield ('has_1byte2', self.__field_has_1byte2, None) 
5934          yield ('has_40bytes', self.__field_has_40bytes, None) 
5935          if self.msg_len: 
5936              yield ('msg', self.__field_msg, None) 
5937          else: 
5938              yield ('msg', self.__field_msg, None) 
5939          if self.has_callback: 
5940              yield ('callback_len', self.__field_callback_len, None) 
5941              yield ('callback', self.__field_callback, None) 
5942          if self.has_priority: 
5943              yield ('priority', self.__field_priority, None) 
5944          if self.has_1byte: 
5945              pass 
5946          yield ('datetime', self.__field_datetime, None) 
5947          yield ('addr_len0', self.__field_addr_len0, None) 
5948          yield ('addr_len1', self.__field_addr_len1, None) 
5949          yield ('addr_len2', self.__field_addr_len2, None) 
5950          yield ('addr_len3', self.__field_addr_len3, None) 
5951          yield ('addr_len4', self.__field_addr_len4, None) 
5952          yield ('addr_len5', self.__field_addr_len5, None) 
5953          yield ('addr_len6', self.__field_addr_len6, None) 
5954          yield ('addr_len7', self.__field_addr_len7, None) 
5955          yield ('addr_len8', self.__field_addr_len8, None) 
5956          yield ('addr_len9', self.__field_addr_len9, None) 
5957          if self.addr_len0: 
5958              yield ('addr0', self.__field_addr0, None) 
5959          if self.addr_len1: 
5960              yield ('addr1', self.__field_addr1, None) 
5961          if self.addr_len2: 
5962              yield ('addr2', self.__field_addr2, None) 
5963          if self.addr_len3: 
5964              yield ('addr3', self.__field_addr3, None) 
5965          if self.addr_len4: 
5966              yield ('addr4', self.__field_addr4, None) 
5967          if self.addr_len5: 
5968              yield ('addr5', self.__field_addr5, None) 
5969          if self.addr_len6: 
5970              yield ('addr6', self.__field_addr6, None) 
5971          if self.addr_len7: 
5972              yield ('addr7', self.__field_addr7, None) 
5973          if self.addr_len8: 
5974              yield ('addr8', self.__field_addr8, None) 
5975          if self.addr_len9: 
5976              yield ('addr9', self.__field_addr9, None) 
5977          if not self.has_1byte and self.has_1byte2: 
5978              pass 
5979          if self.has_1byte2: 
5980              pass 
5981          if self.has_40bytes: 
5982              pass 
5983          yield ('msg_stat', self.__field_msg_stat, None) 
5984