Source Code for Module phones.p_samsungschu740

   1  # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE 
   2   
   3  """Various descriptions of data specific to the Samsung SCH-A950 Phone""" 
   4   
   5  from prototypes import * 
   6  from prototypes_samsung import * 
   7  from p_brew import * 
   8  from p_samsungscha950 import * 
   9   
  10  RT_PATH='brew/mod/mr' 
  11  RT_INDEX_FILE_NAME=RT_PATH+'/MrInfo.db' 
  12  RT_EXCLUDED_FILES=('MrInfo.db',) 
  13   
  14  SND_PATH='brew/mod/18067' 
  15  SND_INDEX_FILE_NAME=SND_PATH+'/MsInfo.db' 
  16  SND_EXCLUDED_FILES=('MsInfo.db', 'ExInfo.db') 
  17   
  18  PIC_PATH='brew/mod/10888' 
  19  PIC_INDEX_FILE_NAME=PIC_PATH+'/Default Album.alb' 
  20  PIC_EXCLUDED_FILES=('Default Album.alb',) 
  21  PIC_TYPE_HEADER=0 
  22  PIC_TYPE_BUILTIN=4 
  23  PIC_TYPE_USERS=3 
  24   
  25  VIDEO_PATH='brew/mod/10890' 
  26  VIDEO_INDEX_FILE_NAME=VIDEO_PATH+'/Default Album.alb' 
  27   
  28  PB_FLG_NOTE=0x0200 
  29  PB_MAX_NOTE_LEN=64 
  30   
  31  CL_MAX_ENTRIES=90 
  32  CL_TYPE_INCOMING=2 
  33  CL_TYPE_OUTGOING=1 
  34  CL_TYPE_MISSED=3 
  35  CL_TYPE_DELETED=5 
  36  CL_VALID_TYPE=frozenset((CL_TYPE_INCOMING, CL_TYPE_OUTGOING, CL_TYPE_MISSED)) 
  37   
  38 -class WRingtoneIndexEntry(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(WRingtoneIndexEntry,self).__init__(**dict) 
  47          if self.__class__ is WRingtoneIndexEntry: 
  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(WRingtoneIndexEntry,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(WRingtoneIndexEntry,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|3\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|3\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|3\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|3\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 WRingtoneIndexFile(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(WRingtoneIndexFile,self).__init__(**dict) 
 180          if self.__class__ is WRingtoneIndexFile: 
 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(WRingtoneIndexFile,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(WRingtoneIndexFile,kwargs) 
 198          if len(args): 
 199              dict2={ 'elementclass': WRingtoneIndexEntry } 
 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': WRingtoneIndexEntry }) 
 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': WRingtoneIndexEntry }) 
 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': WRingtoneIndexEntry }) 
 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': WRingtoneIndexEntry }) 
 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 RRingtoneIndexEntry(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(RRingtoneIndexEntry,self).__init__(**dict) 
 260          if self.__class__ is RRingtoneIndexEntry: 
 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(RRingtoneIndexEntry,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(RRingtoneIndexEntry,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 RRingtoneIndexFile(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(RRingtoneIndexFile,self).__init__(**dict) 
 347          if self.__class__ is RRingtoneIndexFile: 
 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(RRingtoneIndexFile,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(RRingtoneIndexFile,kwargs) 
 365          if len(args): 
 366              dict2={ 'elementclass': RRingtoneIndexEntry } 
 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': RRingtoneIndexEntry }) 
 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': RRingtoneIndexEntry }) 
 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': RRingtoneIndexEntry }) 
 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': RRingtoneIndexEntry }) 
 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 WSoundsIndexEntry(BaseProtogenClass): 
 419      __fields=['name', 'path_prefix', 'pathname', 'eor'] 
 420   
 421 -    def __init__(self, *args, **kwargs): 
 422          dict={} 
 423          # What was supplied to this function 
 424          dict.update(kwargs) 
 425          # Parent constructor 
 426          super(WSoundsIndexEntry,self).__init__(**dict) 
 427          if self.__class__ is WSoundsIndexEntry: 
 428              self._update(args,dict) 
 429   
 430   
 431 -    def getfields(self): 
 432          return self.__fields 
 433   
 434   
 435 -    def _update(self, args, kwargs): 
 436          super(WSoundsIndexEntry,self)._update(args,kwargs) 
 437          keys=kwargs.keys() 
 438          for key in keys: 
 439              if key in self.__fields: 
 440                  setattr(self, key, kwargs[key]) 
 441                  del kwargs[key] 
 442          # Were any unrecognized kwargs passed in? 
 443          if __debug__: 
 444              self._complainaboutunusedargs(WSoundsIndexEntry,kwargs) 
 445          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 446          # Make all P fields that haven't already been constructed 
 447          try: self.__field_name 
 448          except: 
 449              self.__field_name=STRING() 
 450   
 451   
 452 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 453          'Writes this packet to the supplied buffer' 
 454          self._bufferstartoffset=buf.getcurrentoffset() 
 455          try: self.__field_path_prefix 
 456          except: 
 457              self.__field_path_prefix=STRING(**{ 'terminator': None,               'default': '/ff/' }) 
 458          self.__field_path_prefix.writetobuffer(buf) 
 459          self.__field_pathname.writetobuffer(buf) 
 460          try: self.__field_eor 
 461          except: 
 462              self.__field_eor=STRING(**{ 'terminator': None,               'default': '|0|7\x0A' }) 
 463          self.__field_eor.writetobuffer(buf) 
 464          self._bufferendoffset=buf.getcurrentoffset() 
 465          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 466   
 467   
 468 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 469          'Reads this packet from the supplied buffer' 
 470          self._bufferstartoffset=buf.getcurrentoffset() 
 471          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 472          self.__field_path_prefix=STRING(**{ 'terminator': None,               'default': '/ff/' }) 
 473          self.__field_path_prefix.readfrombuffer(buf) 
 474          self.__field_pathname=STRING(**{ 'terminator': None }) 
 475          self.__field_pathname.readfrombuffer(buf) 
 476          self.__field_eor=STRING(**{ 'terminator': None,               'default': '|0|7\x0A' }) 
 477          self.__field_eor.readfrombuffer(buf) 
 478          self._bufferendoffset=buf.getcurrentoffset() 
 479   
 480   
 481 -    def __getfield_name(self): 
 482          return self.__field_name.getvalue() 
 483   
 484 -    def __setfield_name(self, value): 
 485          if isinstance(value,STRING): 
 486              self.__field_name=value 
 487          else: 
 488              self.__field_name=STRING(value,) 
 489   
 490 -    def __delfield_name(self): del self.__field_name 
 491   
 492      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
 493   
 494 -    def __getfield_path_prefix(self): 
 495          try: self.__field_path_prefix 
 496          except: 
 497              self.__field_path_prefix=STRING(**{ 'terminator': None,               'default': '/ff/' }) 
 498          return self.__field_path_prefix.getvalue() 
 499   
 500 -    def __setfield_path_prefix(self, value): 
 501          if isinstance(value,STRING): 
 502              self.__field_path_prefix=value 
 503          else: 
 504              self.__field_path_prefix=STRING(value,**{ 'terminator': None,               'default': '/ff/' }) 
 505   
 506 -    def __delfield_path_prefix(self): del self.__field_path_prefix 
 507   
 508      path_prefix=property(__getfield_path_prefix, __setfield_path_prefix, __delfield_path_prefix, None) 
 509   
 510 -    def __getfield_pathname(self): 
 511          return self.__field_pathname.getvalue() 
 512   
 513 -    def __setfield_pathname(self, value): 
 514          if isinstance(value,STRING): 
 515              self.__field_pathname=value 
 516          else: 
 517              self.__field_pathname=STRING(value,**{ 'terminator': None }) 
 518   
 519 -    def __delfield_pathname(self): del self.__field_pathname 
 520   
 521      pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None) 
 522   
 523 -    def __getfield_eor(self): 
 524          try: self.__field_eor 
 525          except: 
 526              self.__field_eor=STRING(**{ 'terminator': None,               'default': '|0|7\x0A' }) 
 527          return self.__field_eor.getvalue() 
 528   
 529 -    def __setfield_eor(self, value): 
 530          if isinstance(value,STRING): 
 531              self.__field_eor=value 
 532          else: 
 533              self.__field_eor=STRING(value,**{ 'terminator': None,               'default': '|0|7\x0A' }) 
 534   
 535 -    def __delfield_eor(self): del self.__field_eor 
 536   
 537      eor=property(__getfield_eor, __setfield_eor, __delfield_eor, None) 
 538   
 539 -    def iscontainer(self): 
 540          return True 
 541   
 542 -    def containerelements(self): 
 543          yield ('name', self.__field_name, None) 
 544          yield ('path_prefix', self.__field_path_prefix, None) 
 545          yield ('pathname', self.__field_pathname, None) 
 546          yield ('eor', self.__field_eor, None) 
 547   
 548   
 549   
 550   
 551 -class WSoundsIndexFile(BaseProtogenClass): 
 552      __fields=['items'] 
 553   
 554 -    def __init__(self, *args, **kwargs): 
 555          dict={} 
 556          # What was supplied to this function 
 557          dict.update(kwargs) 
 558          # Parent constructor 
 559          super(WSoundsIndexFile,self).__init__(**dict) 
 560          if self.__class__ is WSoundsIndexFile: 
 561              self._update(args,dict) 
 562   
 563   
 564 -    def getfields(self): 
 565          return self.__fields 
 566   
 567   
 568 -    def _update(self, args, kwargs): 
 569          super(WSoundsIndexFile,self)._update(args,kwargs) 
 570          keys=kwargs.keys() 
 571          for key in keys: 
 572              if key in self.__fields: 
 573                  setattr(self, key, kwargs[key]) 
 574                  del kwargs[key] 
 575          # Were any unrecognized kwargs passed in? 
 576          if __debug__: 
 577              self._complainaboutunusedargs(WSoundsIndexFile,kwargs) 
 578          if len(args): 
 579              dict2={ 'elementclass': WSoundsIndexEntry } 
 580              dict2.update(kwargs) 
 581              kwargs=dict2 
 582              self.__field_items=LIST(*args,**dict2) 
 583          # Make all P fields that haven't already been constructed 
 584   
 585   
 586 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 587          'Writes this packet to the supplied buffer' 
 588          self._bufferstartoffset=buf.getcurrentoffset() 
 589          try: self.__field_items 
 590          except: 
 591              self.__field_items=LIST(**{ 'elementclass': WSoundsIndexEntry }) 
 592          self.__field_items.writetobuffer(buf) 
 593          self._bufferendoffset=buf.getcurrentoffset() 
 594          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 595   
 596   
 597 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 598          'Reads this packet from the supplied buffer' 
 599          self._bufferstartoffset=buf.getcurrentoffset() 
 600          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 601          self.__field_items=LIST(**{ 'elementclass': WSoundsIndexEntry }) 
 602          self.__field_items.readfrombuffer(buf) 
 603          self._bufferendoffset=buf.getcurrentoffset() 
 604   
 605   
 606 -    def __getfield_items(self): 
 607          try: self.__field_items 
 608          except: 
 609              self.__field_items=LIST(**{ 'elementclass': WSoundsIndexEntry }) 
 610          return self.__field_items.getvalue() 
 611   
 612 -    def __setfield_items(self, value): 
 613          if isinstance(value,LIST): 
 614              self.__field_items=value 
 615          else: 
 616              self.__field_items=LIST(value,**{ 'elementclass': WSoundsIndexEntry }) 
 617   
 618 -    def __delfield_items(self): del self.__field_items 
 619   
 620      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
 621   
 622 -    def iscontainer(self): 
 623          return True 
 624   
 625 -    def containerelements(self): 
 626          yield ('items', self.__field_items, None) 
 627   
 628   
 629   
 630   
 631 -class RSoundIndexEntry(BaseProtogenClass): 
 632      __fields=['pathname', 'misc'] 
 633   
 634 -    def __init__(self, *args, **kwargs): 
 635          dict={} 
 636          # What was supplied to this function 
 637          dict.update(kwargs) 
 638          # Parent constructor 
 639          super(RSoundIndexEntry,self).__init__(**dict) 
 640          if self.__class__ is RSoundIndexEntry: 
 641              self._update(args,dict) 
 642   
 643   
 644 -    def getfields(self): 
 645          return self.__fields 
 646   
 647   
 648 -    def _update(self, args, kwargs): 
 649          super(RSoundIndexEntry,self)._update(args,kwargs) 
 650          keys=kwargs.keys() 
 651          for key in keys: 
 652              if key in self.__fields: 
 653                  setattr(self, key, kwargs[key]) 
 654                  del kwargs[key] 
 655          # Were any unrecognized kwargs passed in? 
 656          if __debug__: 
 657              self._complainaboutunusedargs(RSoundIndexEntry,kwargs) 
 658          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 659          # Make all P fields that haven't already been constructed 
 660   
 661   
 662 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 663          'Writes this packet to the supplied buffer' 
 664          self._bufferstartoffset=buf.getcurrentoffset() 
 665          self.__field_pathname.writetobuffer(buf) 
 666          self.__field_misc.writetobuffer(buf) 
 667          self._bufferendoffset=buf.getcurrentoffset() 
 668          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 669   
 670   
 671 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 672          'Reads this packet from the supplied buffer' 
 673          self._bufferstartoffset=buf.getcurrentoffset() 
 674          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 675          self.__field_pathname=STRING(**{ 'terminator': 0x7C }) 
 676          self.__field_pathname.readfrombuffer(buf) 
 677          self.__field_misc=STRING(**{ 'terminator': 0x0A }) 
 678          self.__field_misc.readfrombuffer(buf) 
 679          self._bufferendoffset=buf.getcurrentoffset() 
 680   
 681   
 682 -    def __getfield_pathname(self): 
 683          return self.__field_pathname.getvalue() 
 684   
 685 -    def __setfield_pathname(self, value): 
 686          if isinstance(value,STRING): 
 687              self.__field_pathname=value 
 688          else: 
 689              self.__field_pathname=STRING(value,**{ 'terminator': 0x7C }) 
 690   
 691 -    def __delfield_pathname(self): del self.__field_pathname 
 692   
 693      pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None) 
 694   
 695 -    def __getfield_misc(self): 
 696          return self.__field_misc.getvalue() 
 697   
 698 -    def __setfield_misc(self, value): 
 699          if isinstance(value,STRING): 
 700              self.__field_misc=value 
 701          else: 
 702              self.__field_misc=STRING(value,**{ 'terminator': 0x0A }) 
 703   
 704 -    def __delfield_misc(self): del self.__field_misc 
 705   
 706      misc=property(__getfield_misc, __setfield_misc, __delfield_misc, None) 
 707   
 708 -    def iscontainer(self): 
 709          return True 
 710   
 711 -    def containerelements(self): 
 712          yield ('pathname', self.__field_pathname, None) 
 713          yield ('misc', self.__field_misc, None) 
 714   
 715   
 716   
 717   
 718 -class RSoundsIndexFile(BaseProtogenClass): 
 719      __fields=['items'] 
 720   
 721 -    def __init__(self, *args, **kwargs): 
 722          dict={} 
 723          # What was supplied to this function 
 724          dict.update(kwargs) 
 725          # Parent constructor 
 726          super(RSoundsIndexFile,self).__init__(**dict) 
 727          if self.__class__ is RSoundsIndexFile: 
 728              self._update(args,dict) 
 729   
 730   
 731 -    def getfields(self): 
 732          return self.__fields 
 733   
 734   
 735 -    def _update(self, args, kwargs): 
 736          super(RSoundsIndexFile,self)._update(args,kwargs) 
 737          keys=kwargs.keys() 
 738          for key in keys: 
 739              if key in self.__fields: 
 740                  setattr(self, key, kwargs[key]) 
 741                  del kwargs[key] 
 742          # Were any unrecognized kwargs passed in? 
 743          if __debug__: 
 744              self._complainaboutunusedargs(RSoundsIndexFile,kwargs) 
 745          if len(args): 
 746              dict2={ 'elementclass': RSoundIndexEntry } 
 747              dict2.update(kwargs) 
 748              kwargs=dict2 
 749              self.__field_items=LIST(*args,**dict2) 
 750          # Make all P fields that haven't already been constructed 
 751   
 752   
 753 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 754          'Writes this packet to the supplied buffer' 
 755          self._bufferstartoffset=buf.getcurrentoffset() 
 756          try: self.__field_items 
 757          except: 
 758              self.__field_items=LIST(**{ 'elementclass': RSoundIndexEntry }) 
 759          self.__field_items.writetobuffer(buf) 
 760          self._bufferendoffset=buf.getcurrentoffset() 
 761          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 762   
 763   
 764 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 765          'Reads this packet from the supplied buffer' 
 766          self._bufferstartoffset=buf.getcurrentoffset() 
 767          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 768          self.__field_items=LIST(**{ 'elementclass': RSoundIndexEntry }) 
 769          self.__field_items.readfrombuffer(buf) 
 770          self._bufferendoffset=buf.getcurrentoffset() 
 771   
 772   
 773 -    def __getfield_items(self): 
 774          try: self.__field_items 
 775          except: 
 776              self.__field_items=LIST(**{ 'elementclass': RSoundIndexEntry }) 
 777          return self.__field_items.getvalue() 
 778   
 779 -    def __setfield_items(self, value): 
 780          if isinstance(value,LIST): 
 781              self.__field_items=value 
 782          else: 
 783              self.__field_items=LIST(value,**{ 'elementclass': RSoundIndexEntry }) 
 784   
 785 -    def __delfield_items(self): del self.__field_items 
 786   
 787      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
 788   
 789 -    def iscontainer(self): 
 790          return True 
 791   
 792 -    def containerelements(self): 
 793          yield ('items', self.__field_items, None) 
 794   
 795   
 796   
 797   
 798 -class WPictureIndexEntry(BaseProtogenClass): 
 799      __fields=['path_prefix', 'pathname', 'path_name', 'pictype'] 
 800   
 801 -    def __init__(self, *args, **kwargs): 
 802          dict={} 
 803          # What was supplied to this function 
 804          dict.update(kwargs) 
 805          # Parent constructor 
 806          super(WPictureIndexEntry,self).__init__(**dict) 
 807          if self.__class__ is WPictureIndexEntry: 
 808              self._update(args,dict) 
 809   
 810   
 811 -    def getfields(self): 
 812          return self.__fields 
 813   
 814   
 815 -    def _update(self, args, kwargs): 
 816          super(WPictureIndexEntry,self)._update(args,kwargs) 
 817          keys=kwargs.keys() 
 818          for key in keys: 
 819              if key in self.__fields: 
 820                  setattr(self, key, kwargs[key]) 
 821                  del kwargs[key] 
 822          # Were any unrecognized kwargs passed in? 
 823          if __debug__: 
 824              self._complainaboutunusedargs(WPictureIndexEntry,kwargs) 
 825          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 826          # Make all P fields that haven't already been constructed 
 827          try: self.__field_path_prefix 
 828          except: 
 829              self.__field_path_prefix=STRING(**{ 'default': '/ff/' }) 
 830          try: self.__field_pathname 
 831          except: 
 832              self.__field_pathname=STRING(**{ 'terminator': None }) 
 833   
 834   
 835 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 836          'Writes this packet to the supplied buffer' 
 837          self._bufferstartoffset=buf.getcurrentoffset() 
 838          try: self.__field_path_name 
 839          except: 
 840              self.__field_path_name=STRING(**{'sizeinbytes': 258,  'terminator': 0,                 'default': self.path_prefix+self.pathname }) 
 841          self.__field_path_name.writetobuffer(buf) 
 842          try: self.__field_pictype 
 843          except: 
 844              self.__field_pictype=UINT(**{'sizeinbytes': 2,  'default': PIC_TYPE_USERS }) 
 845          self.__field_pictype.writetobuffer(buf) 
 846          self._bufferendoffset=buf.getcurrentoffset() 
 847          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 848   
 849   
 850 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 851          'Reads this packet from the supplied buffer' 
 852          self._bufferstartoffset=buf.getcurrentoffset() 
 853          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 854          self.__field_path_name=STRING(**{'sizeinbytes': 258,  'terminator': 0,                 'default': self.path_prefix+self.pathname }) 
 855          self.__field_path_name.readfrombuffer(buf) 
 856          self.__field_pictype=UINT(**{'sizeinbytes': 2,  'default': PIC_TYPE_USERS }) 
 857          self.__field_pictype.readfrombuffer(buf) 
 858          self._bufferendoffset=buf.getcurrentoffset() 
 859   
 860   
 861 -    def __getfield_path_prefix(self): 
 862          try: self.__field_path_prefix 
 863          except: 
 864              self.__field_path_prefix=STRING(**{ 'default': '/ff/' }) 
 865          return self.__field_path_prefix.getvalue() 
 866   
 867 -    def __setfield_path_prefix(self, value): 
 868          if isinstance(value,STRING): 
 869              self.__field_path_prefix=value 
 870          else: 
 871              self.__field_path_prefix=STRING(value,**{ 'default': '/ff/' }) 
 872   
 873 -    def __delfield_path_prefix(self): del self.__field_path_prefix 
 874   
 875      path_prefix=property(__getfield_path_prefix, __setfield_path_prefix, __delfield_path_prefix, None) 
 876   
 877 -    def __getfield_pathname(self): 
 878          return self.__field_pathname.getvalue() 
 879   
 880 -    def __setfield_pathname(self, value): 
 881          if isinstance(value,STRING): 
 882              self.__field_pathname=value 
 883          else: 
 884              self.__field_pathname=STRING(value,**{ 'terminator': None }) 
 885   
 886 -    def __delfield_pathname(self): del self.__field_pathname 
 887   
 888      pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None) 
 889   
 890 -    def __getfield_path_name(self): 
 891          try: self.__field_path_name 
 892          except: 
 893              self.__field_path_name=STRING(**{'sizeinbytes': 258,  'terminator': 0,                 'default': self.path_prefix+self.pathname }) 
 894          return self.__field_path_name.getvalue() 
 895   
 896 -    def __setfield_path_name(self, value): 
 897          if isinstance(value,STRING): 
 898              self.__field_path_name=value 
 899          else: 
 900              self.__field_path_name=STRING(value,**{'sizeinbytes': 258,  'terminator': 0,                 'default': self.path_prefix+self.pathname }) 
 901   
 902 -    def __delfield_path_name(self): del self.__field_path_name 
 903   
 904      path_name=property(__getfield_path_name, __setfield_path_name, __delfield_path_name, None) 
 905   
 906 -    def __getfield_pictype(self): 
 907          try: self.__field_pictype 
 908          except: 
 909              self.__field_pictype=UINT(**{'sizeinbytes': 2,  'default': PIC_TYPE_USERS }) 
 910          return self.__field_pictype.getvalue() 
 911   
 912 -    def __setfield_pictype(self, value): 
 913          if isinstance(value,UINT): 
 914              self.__field_pictype=value 
 915          else: 
 916              self.__field_pictype=UINT(value,**{'sizeinbytes': 2,  'default': PIC_TYPE_USERS }) 
 917   
 918 -    def __delfield_pictype(self): del self.__field_pictype 
 919   
 920      pictype=property(__getfield_pictype, __setfield_pictype, __delfield_pictype, "0= invalid, 4=builtin, 3=users") 
 921   
 922 -    def iscontainer(self): 
 923          return True 
 924   
 925 -    def containerelements(self): 
 926          yield ('path_prefix', self.__field_path_prefix, None) 
 927          yield ('pathname', self.__field_pathname, None) 
 928          yield ('path_name', self.__field_path_name, None) 
 929          yield ('pictype', self.__field_pictype, "0= invalid, 4=builtin, 3=users") 
 930   
 931   
 932   
 933   
 934 -class WPictureIndexFile(BaseProtogenClass): 
 935      __fields=['header', 'preloaded1', 'preloaded2', 'preloaded3', 'preloaded4', 'preloaded5', 'preloaded6', 'preloaded7', 'preloaded8', 'items'] 
 936   
 937 -    def __init__(self, *args, **kwargs): 
 938          dict={} 
 939          # What was supplied to this function 
 940          dict.update(kwargs) 
 941          # Parent constructor 
 942          super(WPictureIndexFile,self).__init__(**dict) 
 943          if self.__class__ is WPictureIndexFile: 
 944              self._update(args,dict) 
 945   
 946   
 947 -    def getfields(self): 
 948          return self.__fields 
 949   
 950   
 951 -    def _update(self, args, kwargs): 
 952          super(WPictureIndexFile,self)._update(args,kwargs) 
 953          keys=kwargs.keys() 
 954          for key in keys: 
 955              if key in self.__fields: 
 956                  setattr(self, key, kwargs[key]) 
 957                  del kwargs[key] 
 958          # Were any unrecognized kwargs passed in? 
 959          if __debug__: 
 960              self._complainaboutunusedargs(WPictureIndexFile,kwargs) 
 961          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 962          # Make all P fields that haven't already been constructed 
 963   
 964   
 965 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 966          'Writes this packet to the supplied buffer' 
 967          self._bufferstartoffset=buf.getcurrentoffset() 
 968          try: self.__field_header 
 969          except: 
 970              self.__field_header=WPictureIndexEntry(**{ 'pathname': '0|/ff/brew/mod/10888/Default Album|\x0A',                           'path_prefix': '',                           'pictype': PIC_TYPE_HEADER }) 
 971          self.__field_header.writetobuffer(buf) 
 972          try: self.__field_preloaded1 
 973          except: 
 974              self.__field_preloaded1=WPictureIndexEntry(**{ 'pathname': 'Preloaded1',                           'path_prefix': '',                           'pictype': PIC_TYPE_BUILTIN }) 
 975          self.__field_preloaded1.writetobuffer(buf) 
 976          try: self.__field_preloaded2 
 977          except: 
 978              self.__field_preloaded2=WPictureIndexEntry(**{ 'pathname': 'Preloaded2',                           'path_prefix': '',                           'pictype': PIC_TYPE_BUILTIN }) 
 979          self.__field_preloaded2.writetobuffer(buf) 
 980          try: self.__field_preloaded3 
 981          except: 
 982              self.__field_preloaded3=WPictureIndexEntry(**{ 'pathname': 'Preloaded3',                           'path_prefix': '',                           'pictype': PIC_TYPE_BUILTIN }) 
 983          self.__field_preloaded3.writetobuffer(buf) 
 984          try: self.__field_preloaded4 
 985          except: 
 986              self.__field_preloaded4=WPictureIndexEntry(**{ 'pathname': 'Preloaded4',                           'path_prefix': '',                           'pictype': PIC_TYPE_BUILTIN }) 
 987          self.__field_preloaded4.writetobuffer(buf) 
 988          try: self.__field_preloaded5 
 989          except: 
 990              self.__field_preloaded5=WPictureIndexEntry(**{ 'pathname': 'Preloaded5',                           'path_prefix': '',                           'pictype': PIC_TYPE_BUILTIN }) 
 991          self.__field_preloaded5.writetobuffer(buf) 
 992          try: self.__field_preloaded6 
 993          except: 
 994              self.__field_preloaded6=WPictureIndexEntry(**{ 'pathname': 'Preloaded6',                           'path_prefix': '',                           'pictype': PIC_TYPE_BUILTIN }) 
 995          self.__field_preloaded6.writetobuffer(buf) 
 996          try: self.__field_preloaded7 
 997          except: 
 998              self.__field_preloaded7=WPictureIndexEntry(**{ 'pathname': 'Preloaded7',                           'path_prefix': '',                           'pictype': PIC_TYPE_BUILTIN }) 
 999          self.__field_preloaded7.writetobuffer(buf) 
1000          try: self.__field_preloaded8 
1001          except: 
1002              self.__field_preloaded8=WPictureIndexEntry(**{ 'pathname': 'Preloaded8',                           'path_prefix': '',                           'pictype': PIC_TYPE_BUILTIN }) 
1003          self.__field_preloaded8.writetobuffer(buf) 
1004          try: self.__field_items 
1005          except: 
1006              self.__field_items=LIST(**{ 'elementclass': WPictureIndexEntry }) 
1007          self.__field_items.writetobuffer(buf) 
1008          self._bufferendoffset=buf.getcurrentoffset() 
1009          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1010   
1011   
1012 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1013          'Reads this packet from the supplied buffer' 
1014          self._bufferstartoffset=buf.getcurrentoffset() 
1015          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1016          self.__field_header=WPictureIndexEntry(**{ 'pathname': '0|/ff/brew/mod/10888/Default Album|\x0A',                           'path_prefix': '',                           'pictype': PIC_TYPE_HEADER }) 
1017          self.__field_header.readfrombuffer(buf) 
1018          self.__field_preloaded1=WPictureIndexEntry(**{ 'pathname': 'Preloaded1',                           'path_prefix': '',                           'pictype': PIC_TYPE_BUILTIN }) 
1019          self.__field_preloaded1.readfrombuffer(buf) 
1020          self.__field_preloaded2=WPictureIndexEntry(**{ 'pathname': 'Preloaded2',                           'path_prefix': '',                           'pictype': PIC_TYPE_BUILTIN }) 
1021          self.__field_preloaded2.readfrombuffer(buf) 
1022          self.__field_preloaded3=WPictureIndexEntry(**{ 'pathname': 'Preloaded3',                           'path_prefix': '',                           'pictype': PIC_TYPE_BUILTIN }) 
1023          self.__field_preloaded3.readfrombuffer(buf) 
1024          self.__field_preloaded4=WPictureIndexEntry(**{ 'pathname': 'Preloaded4',                           'path_prefix': '',                           'pictype': PIC_TYPE_BUILTIN }) 
1025          self.__field_preloaded4.readfrombuffer(buf) 
1026          self.__field_preloaded5=WPictureIndexEntry(**{ 'pathname': 'Preloaded5',                           'path_prefix': '',                           'pictype': PIC_TYPE_BUILTIN }) 
1027          self.__field_preloaded5.readfrombuffer(buf) 
1028          self.__field_preloaded6=WPictureIndexEntry(**{ 'pathname': 'Preloaded6',                           'path_prefix': '',                           'pictype': PIC_TYPE_BUILTIN }) 
1029          self.__field_preloaded6.readfrombuffer(buf) 
1030          self.__field_preloaded7=WPictureIndexEntry(**{ 'pathname': 'Preloaded7',                           'path_prefix': '',                           'pictype': PIC_TYPE_BUILTIN }) 
1031          self.__field_preloaded7.readfrombuffer(buf) 
1032          self.__field_preloaded8=WPictureIndexEntry(**{ 'pathname': 'Preloaded8',                           'path_prefix': '',                           'pictype': PIC_TYPE_BUILTIN }) 
1033          self.__field_preloaded8.readfrombuffer(buf) 
1034          self.__field_items=LIST(**{ 'elementclass': WPictureIndexEntry }) 
1035          self.__field_items.readfrombuffer(buf) 
1036          self._bufferendoffset=buf.getcurrentoffset() 
1037   
1038   
1039 -    def __getfield_header(self): 
1040          try: self.__field_header 
1041          except: 
1042              self.__field_header=WPictureIndexEntry(**{ 'pathname': '0|/ff/brew/mod/10888/Default Album|\x0A',                           'path_prefix': '',                           'pictype': PIC_TYPE_HEADER }) 
1043          return self.__field_header.getvalue() 
1044   
1045 -    def __setfield_header(self, value): 
1046          if isinstance(value,WPictureIndexEntry): 
1047              self.__field_header=value 
1048          else: 
1049              self.__field_header=WPictureIndexEntry(value,**{ 'pathname': '0|/ff/brew/mod/10888/Default Album|\x0A',                           'path_prefix': '',                           'pictype': PIC_TYPE_HEADER }) 
1050   
1051 -    def __delfield_header(self): del self.__field_header 
1052   
1053      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
1054   
1055 -    def __getfield_preloaded1(self): 
1056          try: self.__field_preloaded1 
1057          except: 
1058              self.__field_preloaded1=WPictureIndexEntry(**{ 'pathname': 'Preloaded1',                           'path_prefix': '',                           'pictype': PIC_TYPE_BUILTIN }) 
1059          return self.__field_preloaded1.getvalue() 
1060   
1061 -    def __setfield_preloaded1(self, value): 
1062          if isinstance(value,WPictureIndexEntry): 
1063              self.__field_preloaded1=value 
1064          else: 
1065              self.__field_preloaded1=WPictureIndexEntry(value,**{ 'pathname': 'Preloaded1',                           'path_prefix': '',                           'pictype': PIC_TYPE_BUILTIN }) 
1066   
1067 -    def __delfield_preloaded1(self): del self.__field_preloaded1 
1068   
1069      preloaded1=property(__getfield_preloaded1, __setfield_preloaded1, __delfield_preloaded1, None) 
1070   
1071 -    def __getfield_preloaded2(self): 
1072          try: self.__field_preloaded2 
1073          except: 
1074              self.__field_preloaded2=WPictureIndexEntry(**{ 'pathname': 'Preloaded2',                           'path_prefix': '',                           'pictype': PIC_TYPE_BUILTIN }) 
1075          return self.__field_preloaded2.getvalue() 
1076   
1077 -    def __setfield_preloaded2(self, value): 
1078          if isinstance(value,WPictureIndexEntry): 
1079              self.__field_preloaded2=value 
1080          else: 
1081              self.__field_preloaded2=WPictureIndexEntry(value,**{ 'pathname': 'Preloaded2',                           'path_prefix': '',                           'pictype': PIC_TYPE_BUILTIN }) 
1082   
1083 -    def __delfield_preloaded2(self): del self.__field_preloaded2 
1084   
1085      preloaded2=property(__getfield_preloaded2, __setfield_preloaded2, __delfield_preloaded2, None) 
1086   
1087 -    def __getfield_preloaded3(self): 
1088          try: self.__field_preloaded3 
1089          except: 
1090              self.__field_preloaded3=WPictureIndexEntry(**{ 'pathname': 'Preloaded3',                           'path_prefix': '',                           'pictype': PIC_TYPE_BUILTIN }) 
1091          return self.__field_preloaded3.getvalue() 
1092   
1093 -    def __setfield_preloaded3(self, value): 
1094          if isinstance(value,WPictureIndexEntry): 
1095              self.__field_preloaded3=value 
1096          else: 
1097              self.__field_preloaded3=WPictureIndexEntry(value,**{ 'pathname': 'Preloaded3',                           'path_prefix': '',                           'pictype': PIC_TYPE_BUILTIN }) 
1098   
1099 -    def __delfield_preloaded3(self): del self.__field_preloaded3 
1100   
1101      preloaded3=property(__getfield_preloaded3, __setfield_preloaded3, __delfield_preloaded3, None) 
1102   
1103 -    def __getfield_preloaded4(self): 
1104          try: self.__field_preloaded4 
1105          except: 
1106              self.__field_preloaded4=WPictureIndexEntry(**{ 'pathname': 'Preloaded4',                           'path_prefix': '',                           'pictype': PIC_TYPE_BUILTIN }) 
1107          return self.__field_preloaded4.getvalue() 
1108   
1109 -    def __setfield_preloaded4(self, value): 
1110          if isinstance(value,WPictureIndexEntry): 
1111              self.__field_preloaded4=value 
1112          else: 
1113              self.__field_preloaded4=WPictureIndexEntry(value,**{ 'pathname': 'Preloaded4',                           'path_prefix': '',                           'pictype': PIC_TYPE_BUILTIN }) 
1114   
1115 -    def __delfield_preloaded4(self): del self.__field_preloaded4 
1116   
1117      preloaded4=property(__getfield_preloaded4, __setfield_preloaded4, __delfield_preloaded4, None) 
1118   
1119 -    def __getfield_preloaded5(self): 
1120          try: self.__field_preloaded5 
1121          except: 
1122              self.__field_preloaded5=WPictureIndexEntry(**{ 'pathname': 'Preloaded5',                           'path_prefix': '',                           'pictype': PIC_TYPE_BUILTIN }) 
1123          return self.__field_preloaded5.getvalue() 
1124   
1125 -    def __setfield_preloaded5(self, value): 
1126          if isinstance(value,WPictureIndexEntry): 
1127              self.__field_preloaded5=value 
1128          else: 
1129              self.__field_preloaded5=WPictureIndexEntry(value,**{ 'pathname': 'Preloaded5',                           'path_prefix': '',                           'pictype': PIC_TYPE_BUILTIN }) 
1130   
1131 -    def __delfield_preloaded5(self): del self.__field_preloaded5 
1132   
1133      preloaded5=property(__getfield_preloaded5, __setfield_preloaded5, __delfield_preloaded5, None) 
1134   
1135 -    def __getfield_preloaded6(self): 
1136          try: self.__field_preloaded6 
1137          except: 
1138              self.__field_preloaded6=WPictureIndexEntry(**{ 'pathname': 'Preloaded6',                           'path_prefix': '',                           'pictype': PIC_TYPE_BUILTIN }) 
1139          return self.__field_preloaded6.getvalue() 
1140   
1141 -    def __setfield_preloaded6(self, value): 
1142          if isinstance(value,WPictureIndexEntry): 
1143              self.__field_preloaded6=value 
1144          else: 
1145              self.__field_preloaded6=WPictureIndexEntry(value,**{ 'pathname': 'Preloaded6',                           'path_prefix': '',                           'pictype': PIC_TYPE_BUILTIN }) 
1146   
1147 -    def __delfield_preloaded6(self): del self.__field_preloaded6 
1148   
1149      preloaded6=property(__getfield_preloaded6, __setfield_preloaded6, __delfield_preloaded6, None) 
1150   
1151 -    def __getfield_preloaded7(self): 
1152          try: self.__field_preloaded7 
1153          except: 
1154              self.__field_preloaded7=WPictureIndexEntry(**{ 'pathname': 'Preloaded7',                           'path_prefix': '',                           'pictype': PIC_TYPE_BUILTIN }) 
1155          return self.__field_preloaded7.getvalue() 
1156   
1157 -    def __setfield_preloaded7(self, value): 
1158          if isinstance(value,WPictureIndexEntry): 
1159              self.__field_preloaded7=value 
1160          else: 
1161              self.__field_preloaded7=WPictureIndexEntry(value,**{ 'pathname': 'Preloaded7',                           'path_prefix': '',                           'pictype': PIC_TYPE_BUILTIN }) 
1162   
1163 -    def __delfield_preloaded7(self): del self.__field_preloaded7 
1164   
1165      preloaded7=property(__getfield_preloaded7, __setfield_preloaded7, __delfield_preloaded7, None) 
1166   
1167 -    def __getfield_preloaded8(self): 
1168          try: self.__field_preloaded8 
1169          except: 
1170              self.__field_preloaded8=WPictureIndexEntry(**{ 'pathname': 'Preloaded8',                           'path_prefix': '',                           'pictype': PIC_TYPE_BUILTIN }) 
1171          return self.__field_preloaded8.getvalue() 
1172   
1173 -    def __setfield_preloaded8(self, value): 
1174          if isinstance(value,WPictureIndexEntry): 
1175              self.__field_preloaded8=value 
1176          else: 
1177              self.__field_preloaded8=WPictureIndexEntry(value,**{ 'pathname': 'Preloaded8',                           'path_prefix': '',                           'pictype': PIC_TYPE_BUILTIN }) 
1178   
1179 -    def __delfield_preloaded8(self): del self.__field_preloaded8 
1180   
1181      preloaded8=property(__getfield_preloaded8, __setfield_preloaded8, __delfield_preloaded8, None) 
1182   
1183 -    def __getfield_items(self): 
1184          try: self.__field_items 
1185          except: 
1186              self.__field_items=LIST(**{ 'elementclass': WPictureIndexEntry }) 
1187          return self.__field_items.getvalue() 
1188   
1189 -    def __setfield_items(self, value): 
1190          if isinstance(value,LIST): 
1191              self.__field_items=value 
1192          else: 
1193              self.__field_items=LIST(value,**{ 'elementclass': WPictureIndexEntry }) 
1194   
1195 -    def __delfield_items(self): del self.__field_items 
1196   
1197      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
1198   
1199 -    def iscontainer(self): 
1200          return True 
1201   
1202 -    def containerelements(self): 
1203          yield ('header', self.__field_header, None) 
1204          yield ('preloaded1', self.__field_preloaded1, None) 
1205          yield ('preloaded2', self.__field_preloaded2, None) 
1206          yield ('preloaded3', self.__field_preloaded3, None) 
1207          yield ('preloaded4', self.__field_preloaded4, None) 
1208          yield ('preloaded5', self.__field_preloaded5, None) 
1209          yield ('preloaded6', self.__field_preloaded6, None) 
1210          yield ('preloaded7', self.__field_preloaded7, None) 
1211          yield ('preloaded8', self.__field_preloaded8, None) 
1212          yield ('items', self.__field_items, None) 
1213   
1214   
1215   
1216   
1217 -class RPictureIndexEntry(BaseProtogenClass): 
1218      __fields=['pathname', 'pictype'] 
1219   
1220 -    def __init__(self, *args, **kwargs): 
1221          dict={} 
1222          # What was supplied to this function 
1223          dict.update(kwargs) 
1224          # Parent constructor 
1225          super(RPictureIndexEntry,self).__init__(**dict) 
1226          if self.__class__ is RPictureIndexEntry: 
1227              self._update(args,dict) 
1228   
1229   
1230 -    def getfields(self): 
1231          return self.__fields 
1232   
1233   
1234 -    def _update(self, args, kwargs): 
1235          super(RPictureIndexEntry,self)._update(args,kwargs) 
1236          keys=kwargs.keys() 
1237          for key in keys: 
1238              if key in self.__fields: 
1239                  setattr(self, key, kwargs[key]) 
1240                  del kwargs[key] 
1241          # Were any unrecognized kwargs passed in? 
1242          if __debug__: 
1243              self._complainaboutunusedargs(RPictureIndexEntry,kwargs) 
1244          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1245          # Make all P fields that haven't already been constructed 
1246   
1247   
1248 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1249          'Writes this packet to the supplied buffer' 
1250          self._bufferstartoffset=buf.getcurrentoffset() 
1251          self.__field_pathname.writetobuffer(buf) 
1252          self.__field_pictype.writetobuffer(buf) 
1253          self._bufferendoffset=buf.getcurrentoffset() 
1254          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1255   
1256   
1257 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1258          'Reads this packet from the supplied buffer' 
1259          self._bufferstartoffset=buf.getcurrentoffset() 
1260          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1261          self.__field_pathname=STRING(**{'sizeinbytes': 258,  'terminator': 0,                 'raiseonunterminatedread': False }) 
1262          self.__field_pathname.readfrombuffer(buf) 
1263          self.__field_pictype=UINT(**{'sizeinbytes': 2}) 
1264          self.__field_pictype.readfrombuffer(buf) 
1265          self._bufferendoffset=buf.getcurrentoffset() 
1266   
1267   
1268 -    def __getfield_pathname(self): 
1269          return self.__field_pathname.getvalue() 
1270   
1271 -    def __setfield_pathname(self, value): 
1272          if isinstance(value,STRING): 
1273              self.__field_pathname=value 
1274          else: 
1275              self.__field_pathname=STRING(value,**{'sizeinbytes': 258,  'terminator': 0,                 'raiseonunterminatedread': False }) 
1276   
1277 -    def __delfield_pathname(self): del self.__field_pathname 
1278   
1279      pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None) 
1280   
1281 -    def __getfield_pictype(self): 
1282          return self.__field_pictype.getvalue() 
1283   
1284 -    def __setfield_pictype(self, value): 
1285          if isinstance(value,UINT): 
1286              self.__field_pictype=value 
1287          else: 
1288              self.__field_pictype=UINT(value,**{'sizeinbytes': 2}) 
1289   
1290 -    def __delfield_pictype(self): del self.__field_pictype 
1291   
1292      pictype=property(__getfield_pictype, __setfield_pictype, __delfield_pictype, "0= invalid, 4=builtin, 3=users") 
1293   
1294 -    def iscontainer(self): 
1295          return True 
1296   
1297 -    def containerelements(self): 
1298          yield ('pathname', self.__field_pathname, None) 
1299          yield ('pictype', self.__field_pictype, "0= invalid, 4=builtin, 3=users") 
1300   
1301   
1302   
1303   
1304 -class RPictureIndexFile(BaseProtogenClass): 
1305      __fields=['items'] 
1306   
1307 -    def __init__(self, *args, **kwargs): 
1308          dict={} 
1309          # What was supplied to this function 
1310          dict.update(kwargs) 
1311          # Parent constructor 
1312          super(RPictureIndexFile,self).__init__(**dict) 
1313          if self.__class__ is RPictureIndexFile: 
1314              self._update(args,dict) 
1315   
1316   
1317 -    def getfields(self): 
1318          return self.__fields 
1319   
1320   
1321 -    def _update(self, args, kwargs): 
1322          super(RPictureIndexFile,self)._update(args,kwargs) 
1323          keys=kwargs.keys() 
1324          for key in keys: 
1325              if key in self.__fields: 
1326                  setattr(self, key, kwargs[key]) 
1327                  del kwargs[key] 
1328          # Were any unrecognized kwargs passed in? 
1329          if __debug__: 
1330              self._complainaboutunusedargs(RPictureIndexFile,kwargs) 
1331          if len(args): 
1332              dict2={ 'elementclass': RPictureIndexEntry } 
1333              dict2.update(kwargs) 
1334              kwargs=dict2 
1335              self.__field_items=LIST(*args,**dict2) 
1336          # Make all P fields that haven't already been constructed 
1337   
1338   
1339 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1340          'Writes this packet to the supplied buffer' 
1341          self._bufferstartoffset=buf.getcurrentoffset() 
1342          try: self.__field_items 
1343          except: 
1344              self.__field_items=LIST(**{ 'elementclass': RPictureIndexEntry }) 
1345          self.__field_items.writetobuffer(buf) 
1346          self._bufferendoffset=buf.getcurrentoffset() 
1347          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1348   
1349   
1350 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1351          'Reads this packet from the supplied buffer' 
1352          self._bufferstartoffset=buf.getcurrentoffset() 
1353          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1354          self.__field_items=LIST(**{ 'elementclass': RPictureIndexEntry }) 
1355          self.__field_items.readfrombuffer(buf) 
1356          self._bufferendoffset=buf.getcurrentoffset() 
1357   
1358   
1359 -    def __getfield_items(self): 
1360          try: self.__field_items 
1361          except: 
1362              self.__field_items=LIST(**{ 'elementclass': RPictureIndexEntry }) 
1363          return self.__field_items.getvalue() 
1364   
1365 -    def __setfield_items(self, value): 
1366          if isinstance(value,LIST): 
1367              self.__field_items=value 
1368          else: 
1369              self.__field_items=LIST(value,**{ 'elementclass': RPictureIndexEntry }) 
1370   
1371 -    def __delfield_items(self): del self.__field_items 
1372   
1373      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
1374   
1375 -    def iscontainer(self): 
1376          return True 
1377   
1378 -    def containerelements(self): 
1379          yield ('items', self.__field_items, None) 
1380   
1381   
1382   
1383   
1384 -class NumberEntry(BaseProtogenClass): 
1385      # Read-From-Buffer-Only Class 
1386      __fields=['number', 'option', 'speeddial', 'ringtone'] 
1387   
1388 -    def __init__(self, *args, **kwargs): 
1389          dict={} 
1390          # What was supplied to this function 
1391          dict.update(kwargs) 
1392          # Parent constructor 
1393          super(NumberEntry,self).__init__(**dict) 
1394          if self.__class__ is NumberEntry: 
1395              self._update(args,dict) 
1396   
1397   
1398 -    def getfields(self): 
1399          return self.__fields 
1400   
1401   
1402 -    def _update(self, args, kwargs): 
1403          super(NumberEntry,self)._update(args,kwargs) 
1404          keys=kwargs.keys() 
1405          for key in keys: 
1406              if key in self.__fields: 
1407                  setattr(self, key, kwargs[key]) 
1408                  del kwargs[key] 
1409          # Were any unrecognized kwargs passed in? 
1410          if __debug__: 
1411              self._complainaboutunusedargs(NumberEntry,kwargs) 
1412          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1413          # Make all P fields that haven't already been constructed 
1414   
1415   
1416 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1417          'Writes this packet to the supplied buffer' 
1418          raise NotImplementedError 
1419   
1420   
1421 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1422          'Reads this packet from the supplied buffer' 
1423          self._bufferstartoffset=buf.getcurrentoffset() 
1424          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1425          self.__field_number=STRING(**{ 'terminator': None,               'pascal': True }) 
1426          self.__field_number.readfrombuffer(buf) 
1427          self.__field_option=UINT(**{'sizeinbytes': 1}) 
1428          self.__field_option.readfrombuffer(buf) 
1429          if self.has_speeddial: 
1430              self.__field_speeddial=UINT(**{'sizeinbytes': 2}) 
1431              self.__field_speeddial.readfrombuffer(buf) 
1432          if self.has_ringtone: 
1433              self.__field_ringtone=STRING(**{ 'terminator': None,                   'pascal': True }) 
1434              self.__field_ringtone.readfrombuffer(buf) 
1435          self._bufferendoffset=buf.getcurrentoffset() 
1436   
1437   
1438 -    def __getfield_number(self): 
1439          return self.__field_number.getvalue() 
1440   
1441 -    def __setfield_number(self, value): 
1442          if isinstance(value,STRING): 
1443              self.__field_number=value 
1444          else: 
1445              self.__field_number=STRING(value,**{ 'terminator': None,               'pascal': True }) 
1446   
1447 -    def __delfield_number(self): del self.__field_number 
1448   
1449      number=property(__getfield_number, __setfield_number, __delfield_number, None) 
1450   
1451 -    def __getfield_option(self): 
1452          return self.__field_option.getvalue() 
1453   
1454 -    def __setfield_option(self, value): 
1455          if isinstance(value,UINT): 
1456              self.__field_option=value 
1457          else: 
1458              self.__field_option=UINT(value,**{'sizeinbytes': 1}) 
1459   
1460 -    def __delfield_option(self): del self.__field_option 
1461   
1462      option=property(__getfield_option, __setfield_option, __delfield_option, None) 
1463   
1464 -    def __getfield_speeddial(self): 
1465          return self.__field_speeddial.getvalue() 
1466   
1467 -    def __setfield_speeddial(self, value): 
1468          if isinstance(value,UINT): 
1469              self.__field_speeddial=value 
1470          else: 
1471              self.__field_speeddial=UINT(value,**{'sizeinbytes': 2}) 
1472   
1473 -    def __delfield_speeddial(self): del self.__field_speeddial 
1474   
1475      speeddial=property(__getfield_speeddial, __setfield_speeddial, __delfield_speeddial, None) 
1476   
1477 -    def __getfield_ringtone(self): 
1478          return self.__field_ringtone.getvalue() 
1479   
1480 -    def __setfield_ringtone(self, value): 
1481          if isinstance(value,STRING): 
1482              self.__field_ringtone=value 
1483          else: 
1484              self.__field_ringtone=STRING(value,**{ 'terminator': None,                   'pascal': True }) 
1485   
1486 -    def __delfield_ringtone(self): del self.__field_ringtone 
1487   
1488      ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 
1489   
1490 -    def iscontainer(self): 
1491          return True 
1492   
1493 -    def containerelements(self): 
1494          yield ('number', self.__field_number, None) 
1495          yield ('option', self.__field_option, None) 
1496          if self.has_speeddial: 
1497              yield ('speeddial', self.__field_speeddial, None) 
1498          if self.has_ringtone: 
1499              yield ('ringtone', self.__field_ringtone, None) 
1500   
1501      @property 
1502 -    def has_speeddial(self): 
1503          return bool(self.option & PB_FLG_SPEEDDIAL) 
1504      @property 
1505 -    def has_ringtone(self): 
1506          return bool(self.option & PB_FLG_RINGTONE) 
1507      @property 
1508 -    def is_primary(self): 
1509          return bool(self.option & PB_FLG_PRIMARY) 
1510   
1511   
1512   
1513   
1514 -class PBEntry(BaseProtogenClass): 
1515      # Read-From-Buffer-Only Class 
1516      __fields=['info', 'name', 'email', 'email2', 'home', 'work', 'cell', 'fax', 'cell2', 'note', 'datetime', 'group', 'wallpaper', 'wallpaper_range'] 
1517   
1518 -    def __init__(self, *args, **kwargs): 
1519          dict={} 
1520          # What was supplied to this function 
1521          dict.update(kwargs) 
1522          # Parent constructor 
1523          super(PBEntry,self).__init__(**dict) 
1524          if self.__class__ is PBEntry: 
1525              self._update(args,dict) 
1526   
1527   
1528 -    def getfields(self): 
1529          return self.__fields 
1530   
1531   
1532 -    def _update(self, args, kwargs): 
1533          super(PBEntry,self)._update(args,kwargs) 
1534          keys=kwargs.keys() 
1535          for key in keys: 
1536              if key in self.__fields: 
1537                  setattr(self, key, kwargs[key]) 
1538                  del kwargs[key] 
1539          # Were any unrecognized kwargs passed in? 
1540          if __debug__: 
1541              self._complainaboutunusedargs(PBEntry,kwargs) 
1542          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1543          # Make all P fields that haven't already been constructed 
1544   
1545   
1546 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1547          'Writes this packet to the supplied buffer' 
1548          raise NotImplementedError 
1549   
1550   
1551 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1552          'Reads this packet from the supplied buffer' 
1553          self._bufferstartoffset=buf.getcurrentoffset() 
1554          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1555          self.__field_info=UINT(**{'sizeinbytes': 2}) 
1556          self.__field_info.readfrombuffer(buf) 
1557          DONTCARE(**{'sizeinbytes': 2}).readfrombuffer(buf) 
1558          if self.has_name: 
1559              self.__field_name=USTRING(**{ 'terminator': None,                    'encoding': ENCODING,                    'pascal': True }) 
1560              self.__field_name.readfrombuffer(buf) 
1561          if self.has_email: 
1562              self.__field_email=USTRING(**{ 'terminator': None,                    'encoding': ENCODING,                    'pascal': True }) 
1563              self.__field_email.readfrombuffer(buf) 
1564          if self.has_email2: 
1565              self.__field_email2=USTRING(**{ 'terminator': None,                    'encoding': ENCODING,                   'pascal': True }) 
1566              self.__field_email2.readfrombuffer(buf) 
1567          if self.has_home: 
1568              self.__field_home=NumberEntry() 
1569              self.__field_home.readfrombuffer(buf) 
1570          if self.has_work: 
1571              self.__field_work=NumberEntry() 
1572              self.__field_work.readfrombuffer(buf) 
1573          if self.has_cell: 
1574              self.__field_cell=NumberEntry() 
1575              self.__field_cell.readfrombuffer(buf) 
1576          if self.has_fax: 
1577              self.__field_fax=NumberEntry() 
1578              self.__field_fax.readfrombuffer(buf) 
1579          if self.has_cell2: 
1580              self.__field_cell2=NumberEntry() 
1581              self.__field_cell2.readfrombuffer(buf) 
1582          if self.has_note: 
1583              self.__field_note=STRING(**{ 'terminator': None,                   'pascal': True }) 
1584              self.__field_note.readfrombuffer(buf) 
1585          if self.has_date: 
1586              self.__field_datetime=DateTime(**{'sizeinbytes': 4}) 
1587              self.__field_datetime.readfrombuffer(buf) 
1588          if self.hsa_group: 
1589              self.__field_group=UINT(**{'sizeinbytes': 1}) 
1590              self.__field_group.readfrombuffer(buf) 
1591          if self.has_wallpaper: 
1592              self.__field_wallpaper=STRING(**{ 'terminator': None,                   'pascal': True }) 
1593              self.__field_wallpaper.readfrombuffer(buf) 
1594              self.__field_wallpaper_range=UINT(**{'sizeinbytes': 4}) 
1595              self.__field_wallpaper_range.readfrombuffer(buf) 
1596          self._bufferendoffset=buf.getcurrentoffset() 
1597   
1598   
1599 -    def __getfield_info(self): 
1600          return self.__field_info.getvalue() 
1601   
1602 -    def __setfield_info(self, value): 
1603          if isinstance(value,UINT): 
1604              self.__field_info=value 
1605          else: 
1606              self.__field_info=UINT(value,**{'sizeinbytes': 2}) 
1607   
1608 -    def __delfield_info(self): del self.__field_info 
1609   
1610      info=property(__getfield_info, __setfield_info, __delfield_info, None) 
1611   
1612 -    def __getfield_name(self): 
1613          return self.__field_name.getvalue() 
1614   
1615 -    def __setfield_name(self, value): 
1616          if isinstance(value,USTRING): 
1617              self.__field_name=value 
1618          else: 
1619              self.__field_name=USTRING(value,**{ 'terminator': None,                    'encoding': ENCODING,                    'pascal': True }) 
1620   
1621 -    def __delfield_name(self): del self.__field_name 
1622   
1623      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
1624   
1625 -    def __getfield_email(self): 
1626          return self.__field_email.getvalue() 
1627   
1628 -    def __setfield_email(self, value): 
1629          if isinstance(value,USTRING): 
1630              self.__field_email=value 
1631          else: 
1632              self.__field_email=USTRING(value,**{ 'terminator': None,                    'encoding': ENCODING,                    'pascal': True }) 
1633   
1634 -    def __delfield_email(self): del self.__field_email 
1635   
1636      email=property(__getfield_email, __setfield_email, __delfield_email, None) 
1637   
1638 -    def __getfield_email2(self): 
1639          return self.__field_email2.getvalue() 
1640   
1641 -    def __setfield_email2(self, value): 
1642          if isinstance(value,USTRING): 
1643              self.__field_email2=value 
1644          else: 
1645              self.__field_email2=USTRING(value,**{ 'terminator': None,                    'encoding': ENCODING,                   'pascal': True }) 
1646   
1647 -    def __delfield_email2(self): del self.__field_email2 
1648   
1649      email2=property(__getfield_email2, __setfield_email2, __delfield_email2, None) 
1650   
1651 -    def __getfield_home(self): 
1652          return self.__field_home.getvalue() 
1653   
1654 -    def __setfield_home(self, value): 
1655          if isinstance(value,NumberEntry): 
1656              self.__field_home=value 
1657          else: 
1658              self.__field_home=NumberEntry(value,) 
1659   
1660 -    def __delfield_home(self): del self.__field_home 
1661   
1662      home=property(__getfield_home, __setfield_home, __delfield_home, None) 
1663   
1664 -    def __getfield_work(self): 
1665          return self.__field_work.getvalue() 
1666   
1667 -    def __setfield_work(self, value): 
1668          if isinstance(value,NumberEntry): 
1669              self.__field_work=value 
1670          else: 
1671              self.__field_work=NumberEntry(value,) 
1672   
1673 -    def __delfield_work(self): del self.__field_work 
1674   
1675      work=property(__getfield_work, __setfield_work, __delfield_work, None) 
1676   
1677 -    def __getfield_cell(self): 
1678          return self.__field_cell.getvalue() 
1679   
1680 -    def __setfield_cell(self, value): 
1681          if isinstance(value,NumberEntry): 
1682              self.__field_cell=value 
1683          else: 
1684              self.__field_cell=NumberEntry(value,) 
1685   
1686 -    def __delfield_cell(self): del self.__field_cell 
1687   
1688      cell=property(__getfield_cell, __setfield_cell, __delfield_cell, None) 
1689   
1690 -    def __getfield_fax(self): 
1691          return self.__field_fax.getvalue() 
1692   
1693 -    def __setfield_fax(self, value): 
1694          if isinstance(value,NumberEntry): 
1695              self.__field_fax=value 
1696          else: 
1697              self.__field_fax=NumberEntry(value,) 
1698   
1699 -    def __delfield_fax(self): del self.__field_fax 
1700   
1701      fax=property(__getfield_fax, __setfield_fax, __delfield_fax, None) 
1702   
1703 -    def __getfield_cell2(self): 
1704          return self.__field_cell2.getvalue() 
1705   
1706 -    def __setfield_cell2(self, value): 
1707          if isinstance(value,NumberEntry): 
1708              self.__field_cell2=value 
1709          else: 
1710              self.__field_cell2=NumberEntry(value,) 
1711   
1712 -    def __delfield_cell2(self): del self.__field_cell2 
1713   
1714      cell2=property(__getfield_cell2, __setfield_cell2, __delfield_cell2, None) 
1715   
1716 -    def __getfield_note(self): 
1717          return self.__field_note.getvalue() 
1718   
1719 -    def __setfield_note(self, value): 
1720          if isinstance(value,STRING): 
1721              self.__field_note=value 
1722          else: 
1723              self.__field_note=STRING(value,**{ 'terminator': None,                   'pascal': True }) 
1724   
1725 -    def __delfield_note(self): del self.__field_note 
1726   
1727      note=property(__getfield_note, __setfield_note, __delfield_note, None) 
1728   
1729 -    def __getfield_datetime(self): 
1730          return self.__field_datetime.getvalue() 
1731   
1732 -    def __setfield_datetime(self, value): 
1733          if isinstance(value,DateTime): 
1734              self.__field_datetime=value 
1735          else: 
1736              self.__field_datetime=DateTime(value,**{'sizeinbytes': 4}) 
1737   
1738 -    def __delfield_datetime(self): del self.__field_datetime 
1739   
1740      datetime=property(__getfield_datetime, __setfield_datetime, __delfield_datetime, None) 
1741   
1742 -    def __getfield_group(self): 
1743          return self.__field_group.getvalue() 
1744   
1745 -    def __setfield_group(self, value): 
1746          if isinstance(value,UINT): 
1747              self.__field_group=value 
1748          else: 
1749              self.__field_group=UINT(value,**{'sizeinbytes': 1}) 
1750   
1751 -    def __delfield_group(self): del self.__field_group 
1752   
1753      group=property(__getfield_group, __setfield_group, __delfield_group, None) 
1754   
1755 -    def __getfield_wallpaper(self): 
1756          return self.__field_wallpaper.getvalue() 
1757   
1758 -    def __setfield_wallpaper(self, value): 
1759          if isinstance(value,STRING): 
1760              self.__field_wallpaper=value 
1761          else: 
1762              self.__field_wallpaper=STRING(value,**{ 'terminator': None,                   'pascal': True }) 
1763   
1764 -    def __delfield_wallpaper(self): del self.__field_wallpaper 
1765   
1766      wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None) 
1767   
1768 -    def __getfield_wallpaper_range(self): 
1769          return self.__field_wallpaper_range.getvalue() 
1770   
1771 -    def __setfield_wallpaper_range(self, value): 
1772          if isinstance(value,UINT): 
1773              self.__field_wallpaper_range=value 
1774          else: 
1775              self.__field_wallpaper_range=UINT(value,**{'sizeinbytes': 4}) 
1776   
1777 -    def __delfield_wallpaper_range(self): del self.__field_wallpaper_range 
1778   
1779      wallpaper_range=property(__getfield_wallpaper_range, __setfield_wallpaper_range, __delfield_wallpaper_range, None) 
1780   
1781 -    def iscontainer(self): 
1782          return True 
1783   
1784 -    def containerelements(self): 
1785          yield ('info', self.__field_info, None) 
1786          if self.has_name: 
1787              yield ('name', self.__field_name, None) 
1788          if self.has_email: 
1789              yield ('email', self.__field_email, None) 
1790          if self.has_email2: 
1791              yield ('email2', self.__field_email2, None) 
1792          if self.has_home: 
1793              yield ('home', self.__field_home, None) 
1794          if self.has_work: 
1795              yield ('work', self.__field_work, None) 
1796          if self.has_cell: 
1797              yield ('cell', self.__field_cell, None) 
1798          if self.has_fax: 
1799              yield ('fax', self.__field_fax, None) 
1800          if self.has_cell2: 
1801              yield ('cell2', self.__field_cell2, None) 
1802          if self.has_note: 
1803              yield ('note', self.__field_note, None) 
1804          if self.has_date: 
1805              yield ('datetime', self.__field_datetime, None) 
1806          if self.hsa_group: 
1807              yield ('group', self.__field_group, None) 
1808          if self.has_wallpaper: 
1809              yield ('wallpaper', self.__field_wallpaper, None) 
1810              yield ('wallpaper_range', self.__field_wallpaper_range, None) 
1811   
1812      @property 
1813 -    def has_name(self): 
1814          return bool(self.info & PB_FLG_NAME) 
1815      @property 
1816 -    def has_email(self): 
1817          return bool(self.info & PB_FLG_EMAIL) 
1818      @property 
1819 -    def has_email2(self): 
1820          return bool(self.info & PB_FLG_EMAIL2) 
1821      @property 
1822 -    def has_home(self): 
1823          return bool(self.info & PB_FLG_HOME) 
1824      @property 
1825 -    def has_work(self): 
1826          return bool(self.info & PB_FLG_WORK) 
1827      @property 
1828 -    def has_cell(self): 
1829          return bool(self.info & PB_FLG_CELL) 
1830      @property 
1831 -    def has_fax(self): 
1832          return bool(self.info & PB_FLG_FAX) 
1833      @property 
1834 -    def has_cell2(self): 
1835          return bool(self.info & PB_FLG_CELL2) 
1836      @property 
1837 -    def has_note(self): 
1838          return bool(self.info & PB_FLG_NOTE) 
1839      @property 
1840 -    def has_date(self): 
1841          return bool(self.info & PB_FLG_DATE) 
1842      @property 
1843 -    def has_group(self): 
1844          return bool(self.info & PB_FLG_GROUP) 
1845      @property 
1846 -    def has_wallpaper(self): 
1847          return bool(self.info & PB_FLG_WP) 
1848   
1849   
1850   
1851   
1852 -class LenEntry(BaseProtogenClass): 
1853      # Read-From-Buffer-Only Class 
1854      __fields=['itemlen'] 
1855   
1856 -    def __init__(self, *args, **kwargs): 
1857          dict={} 
1858          # What was supplied to this function 
1859          dict.update(kwargs) 
1860          # Parent constructor 
1861          super(LenEntry,self).__init__(**dict) 
1862          if self.__class__ is LenEntry: 
1863              self._update(args,dict) 
1864   
1865   
1866 -    def getfields(self): 
1867          return self.__fields 
1868   
1869   
1870 -    def _update(self, args, kwargs): 
1871          super(LenEntry,self)._update(args,kwargs) 
1872          keys=kwargs.keys() 
1873          for key in keys: 
1874              if key in self.__fields: 
1875                  setattr(self, key, kwargs[key]) 
1876                  del kwargs[key] 
1877          # Were any unrecognized kwargs passed in? 
1878          if __debug__: 
1879              self._complainaboutunusedargs(LenEntry,kwargs) 
1880          if len(args): 
1881              dict2={'sizeinbytes': 2,  'default': 0 } 
1882              dict2.update(kwargs) 
1883              kwargs=dict2 
1884              self.__field_itemlen=UINT(*args,**dict2) 
1885          # Make all P fields that haven't already been constructed 
1886   
1887   
1888 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1889          'Writes this packet to the supplied buffer' 
1890          raise NotImplementedError 
1891   
1892   
1893 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1894          'Reads this packet from the supplied buffer' 
1895          self._bufferstartoffset=buf.getcurrentoffset() 
1896          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1897          self.__field_itemlen=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1898          self.__field_itemlen.readfrombuffer(buf) 
1899          self._bufferendoffset=buf.getcurrentoffset() 
1900   
1901   
1902 -    def __getfield_itemlen(self): 
1903          try: self.__field_itemlen 
1904          except: 
1905              self.__field_itemlen=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
1906          return self.__field_itemlen.getvalue() 
1907   
1908 -    def __setfield_itemlen(self, value): 
1909          if isinstance(value,UINT): 
1910              self.__field_itemlen=value 
1911          else: 
1912              self.__field_itemlen=UINT(value,**{'sizeinbytes': 2,  'default': 0 }) 
1913   
1914 -    def __delfield_itemlen(self): del self.__field_itemlen 
1915   
1916      itemlen=property(__getfield_itemlen, __setfield_itemlen, __delfield_itemlen, None) 
1917   
1918 -    def iscontainer(self): 
1919          return True 
1920   
1921 -    def containerelements(self): 
1922          yield ('itemlen', self.__field_itemlen, None) 
1923   
1924   
1925   
1926   
1927 -class PBFile(BaseProtogenClass): 
1928      # Read-From-Buffer-Only Class 
1929      __fields=['lens', 'items'] 
1930   
1931 -    def __init__(self, *args, **kwargs): 
1932          dict={} 
1933          # What was supplied to this function 
1934          dict.update(kwargs) 
1935          # Parent constructor 
1936          super(PBFile,self).__init__(**dict) 
1937          if self.__class__ is PBFile: 
1938              self._update(args,dict) 
1939   
1940   
1941 -    def getfields(self): 
1942          return self.__fields 
1943   
1944   
1945 -    def _update(self, args, kwargs): 
1946          super(PBFile,self)._update(args,kwargs) 
1947          keys=kwargs.keys() 
1948          for key in keys: 
1949              if key in self.__fields: 
1950                  setattr(self, key, kwargs[key]) 
1951                  del kwargs[key] 
1952          # Were any unrecognized kwargs passed in? 
1953          if __debug__: 
1954              self._complainaboutunusedargs(PBFile,kwargs) 
1955          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1956          # Make all P fields that haven't already been constructed 
1957   
1958   
1959 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1960          'Writes this packet to the supplied buffer' 
1961          raise NotImplementedError 
1962   
1963   
1964 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1965          'Reads this packet from the supplied buffer' 
1966          self._bufferstartoffset=buf.getcurrentoffset() 
1967          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1968          self.__field_lens=LIST(**{ 'elementclass': LenEntry,             'length': 8,             'createdefault': True }) 
1969          self.__field_lens.readfrombuffer(buf) 
1970          self.__field_items=LIST(**{ 'elementclass': PBEntry }) 
1971          self.__field_items.readfrombuffer(buf) 
1972          self._bufferendoffset=buf.getcurrentoffset() 
1973   
1974   
1975 -    def __getfield_lens(self): 
1976          try: self.__field_lens 
1977          except: 
1978              self.__field_lens=LIST(**{ 'elementclass': LenEntry,             'length': 8,             'createdefault': True }) 
1979          return self.__field_lens.getvalue() 
1980   
1981 -    def __setfield_lens(self, value): 
1982          if isinstance(value,LIST): 
1983              self.__field_lens=value 
1984          else: 
1985              self.__field_lens=LIST(value,**{ 'elementclass': LenEntry,             'length': 8,             'createdefault': True }) 
1986   
1987 -    def __delfield_lens(self): del self.__field_lens 
1988   
1989      lens=property(__getfield_lens, __setfield_lens, __delfield_lens, None) 
1990   
1991 -    def __getfield_items(self): 
1992          try: self.__field_items 
1993          except: 
1994              self.__field_items=LIST(**{ 'elementclass': PBEntry }) 
1995          return self.__field_items.getvalue() 
1996   
1997 -    def __setfield_items(self, value): 
1998          if isinstance(value,LIST): 
1999              self.__field_items=value 
2000          else: 
2001              self.__field_items=LIST(value,**{ 'elementclass': PBEntry }) 
2002   
2003 -    def __delfield_items(self): del self.__field_items 
2004   
2005      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
2006   
2007 -    def iscontainer(self): 
2008          return True 
2009   
2010 -    def containerelements(self): 
2011          yield ('lens', self.__field_lens, None) 
2012          yield ('items', self.__field_items, None) 
2013   
2014   
2015   
2016   
2017 -class PBFileHeader(BaseProtogenClass): 
2018      # Read-From-Buffer-Only Class 
2019      __fields=['lens'] 
2020   
2021 -    def __init__(self, *args, **kwargs): 
2022          dict={} 
2023          # What was supplied to this function 
2024          dict.update(kwargs) 
2025          # Parent constructor 
2026          super(PBFileHeader,self).__init__(**dict) 
2027          if self.__class__ is PBFileHeader: 
2028              self._update(args,dict) 
2029   
2030   
2031 -    def getfields(self): 
2032          return self.__fields 
2033   
2034   
2035 -    def _update(self, args, kwargs): 
2036          super(PBFileHeader,self)._update(args,kwargs) 
2037          keys=kwargs.keys() 
2038          for key in keys: 
2039              if key in self.__fields: 
2040                  setattr(self, key, kwargs[key]) 
2041                  del kwargs[key] 
2042          # Were any unrecognized kwargs passed in? 
2043          if __debug__: 
2044              self._complainaboutunusedargs(PBFileHeader,kwargs) 
2045          if len(args): 
2046              dict2={ 'elementclass': LenEntry,             'length': 8,             'createdefault': True } 
2047              dict2.update(kwargs) 
2048              kwargs=dict2 
2049              self.__field_lens=LIST(*args,**dict2) 
2050          # Make all P fields that haven't already been constructed 
2051   
2052   
2053 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2054          'Writes this packet to the supplied buffer' 
2055          raise NotImplementedError 
2056   
2057   
2058 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2059          'Reads this packet from the supplied buffer' 
2060          self._bufferstartoffset=buf.getcurrentoffset() 
2061          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2062          self.__field_lens=LIST(**{ 'elementclass': LenEntry,             'length': 8,             'createdefault': True }) 
2063          self.__field_lens.readfrombuffer(buf) 
2064          self._bufferendoffset=buf.getcurrentoffset() 
2065   
2066   
2067 -    def __getfield_lens(self): 
2068          try: self.__field_lens 
2069          except: 
2070              self.__field_lens=LIST(**{ 'elementclass': LenEntry,             'length': 8,             'createdefault': True }) 
2071          return self.__field_lens.getvalue() 
2072   
2073 -    def __setfield_lens(self, value): 
2074          if isinstance(value,LIST): 
2075              self.__field_lens=value 
2076          else: 
2077              self.__field_lens=LIST(value,**{ 'elementclass': LenEntry,             'length': 8,             'createdefault': True }) 
2078   
2079 -    def __delfield_lens(self): del self.__field_lens 
2080   
2081      lens=property(__getfield_lens, __setfield_lens, __delfield_lens, None) 
2082   
2083 -    def iscontainer(self): 
2084          return True 
2085   
2086 -    def containerelements(self): 
2087          yield ('lens', self.__field_lens, None) 
2088   
2089   
2090   
2091   
2092 -class ss_number_entry(BaseProtogenClass): 
2093      __fields=['number', 'speeddial', 'primary', 'ringtone'] 
2094   
2095 -    def __init__(self, *args, **kwargs): 
2096          dict={} 
2097          # What was supplied to this function 
2098          dict.update(kwargs) 
2099          # Parent constructor 
2100          super(ss_number_entry,self).__init__(**dict) 
2101          if self.__class__ is ss_number_entry: 
2102              self._update(args,dict) 
2103   
2104   
2105 -    def getfields(self): 
2106          return self.__fields 
2107   
2108   
2109 -    def _update(self, args, kwargs): 
2110          super(ss_number_entry,self)._update(args,kwargs) 
2111          keys=kwargs.keys() 
2112          for key in keys: 
2113              if key in self.__fields: 
2114                  setattr(self, key, kwargs[key]) 
2115                  del kwargs[key] 
2116          # Were any unrecognized kwargs passed in? 
2117          if __debug__: 
2118              self._complainaboutunusedargs(ss_number_entry,kwargs) 
2119          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2120          # Make all P fields that haven't already been constructed 
2121   
2122   
2123 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2124          'Writes this packet to the supplied buffer' 
2125          self._bufferstartoffset=buf.getcurrentoffset() 
2126          try: self.__field_number 
2127          except: 
2128              self.__field_number=STRING(**{ 'terminator': 0,               'default': '',               'maxsizeinbytes': PB_MAX_NUMBER_LEN,               'raiseontruncate': False }) 
2129          self.__field_number.writetobuffer(buf) 
2130          try: self.__field_speeddial 
2131          except: 
2132              self.__field_speeddial=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
2133          self.__field_speeddial.writetobuffer(buf) 
2134          try: self.__field_primary 
2135          except: 
2136              self.__field_primary=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
2137          self.__field_primary.writetobuffer(buf) 
2138          try: self.__field__gen_p_samsungschu740_244 
2139          except: 
2140              self.__field__gen_p_samsungschu740_244=DONTCARE(**{'sizeinbytes': 8}) 
2141          self.__field__gen_p_samsungschu740_244.writetobuffer(buf) 
2142          try: self.__field_ringtone 
2143          except: 
2144              self.__field_ringtone=STRING(**{ 'terminator': 0,               'default': '' }) 
2145          self.__field_ringtone.writetobuffer(buf) 
2146          self._bufferendoffset=buf.getcurrentoffset() 
2147          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2148   
2149   
2150 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2151          'Reads this packet from the supplied buffer' 
2152          self._bufferstartoffset=buf.getcurrentoffset() 
2153          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2154          self.__field_number=STRING(**{ 'terminator': 0,               'default': '',               'maxsizeinbytes': PB_MAX_NUMBER_LEN,               'raiseontruncate': False }) 
2155          self.__field_number.readfrombuffer(buf) 
2156          self.__field_speeddial=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
2157          self.__field_speeddial.readfrombuffer(buf) 
2158          self.__field_primary=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
2159          self.__field_primary.readfrombuffer(buf) 
2160          self.__field__gen_p_samsungschu740_244=DONTCARE(**{'sizeinbytes': 8}) 
2161          self.__field__gen_p_samsungschu740_244.readfrombuffer(buf) 
2162          self.__field_ringtone=STRING(**{ 'terminator': 0,               'default': '' }) 
2163          self.__field_ringtone.readfrombuffer(buf) 
2164          self._bufferendoffset=buf.getcurrentoffset() 
2165   
2166   
2167 -    def __getfield_number(self): 
2168          try: self.__field_number 
2169          except: 
2170              self.__field_number=STRING(**{ 'terminator': 0,               'default': '',               'maxsizeinbytes': PB_MAX_NUMBER_LEN,               'raiseontruncate': False }) 
2171          return self.__field_number.getvalue() 
2172   
2173 -    def __setfield_number(self, value): 
2174          if isinstance(value,STRING): 
2175              self.__field_number=value 
2176          else: 
2177              self.__field_number=STRING(value,**{ 'terminator': 0,               'default': '',               'maxsizeinbytes': PB_MAX_NUMBER_LEN,               'raiseontruncate': False }) 
2178   
2179 -    def __delfield_number(self): del self.__field_number 
2180   
2181      number=property(__getfield_number, __setfield_number, __delfield_number, None) 
2182   
2183 -    def __getfield_speeddial(self): 
2184          try: self.__field_speeddial 
2185          except: 
2186              self.__field_speeddial=UINT(**{'sizeinbytes': 2,  'default': 0 }) 
2187          return self.__field_speeddial.getvalue() 
2188   
2189 -    def __setfield_speeddial(self, value): 
2190          if isinstance(value,UINT): 
2191              self.__field_speeddial=value 
2192          else: 
2193              self.__field_speeddial=UINT(value,**{'sizeinbytes': 2,  'default': 0 }) 
2194   
2195 -    def __delfield_speeddial(self): del self.__field_speeddial 
2196   
2197      speeddial=property(__getfield_speeddial, __setfield_speeddial, __delfield_speeddial, None) 
2198   
2199 -    def __getfield_primary(self): 
2200          try: self.__field_primary 
2201          except: 
2202              self.__field_primary=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
2203          return self.__field_primary.getvalue() 
2204   
2205 -    def __setfield_primary(self, value): 
2206          if isinstance(value,UINT): 
2207              self.__field_primary=value 
2208          else: 
2209              self.__field_primary=UINT(value,**{'sizeinbytes': 1,  'default': 0 }) 
2210   
2211 -    def __delfield_primary(self): del self.__field_primary 
2212   
2213      primary=property(__getfield_primary, __setfield_primary, __delfield_primary, None) 
2214   
2215 -    def __getfield_ringtone(self): 
2216          try: self.__field_ringtone 
2217          except: 
2218              self.__field_ringtone=STRING(**{ 'terminator': 0,               'default': '' }) 
2219          return self.__field_ringtone.getvalue() 
2220   
2221 -    def __setfield_ringtone(self, value): 
2222          if isinstance(value,STRING): 
2223              self.__field_ringtone=value 
2224          else: 
2225              self.__field_ringtone=STRING(value,**{ 'terminator': 0,               'default': '' }) 
2226   
2227 -    def __delfield_ringtone(self): del self.__field_ringtone 
2228   
2229      ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 
2230   
2231 -    def iscontainer(self): 
2232          return True 
2233   
2234 -    def containerelements(self): 
2235          yield ('number', self.__field_number, None) 
2236          yield ('speeddial', self.__field_speeddial, None) 
2237          yield ('primary', self.__field_primary, None) 
2238          yield ('ringtone', self.__field_ringtone, None) 
2239   
2240   
2241   
2242   
2243 -class ss_pb_entry(BaseProtogenClass): 
2244      __fields=['name', 'email', 'email2', 'note', 'wallpaper', 'wallpaper_range', 'home', 'work', 'cell', 'dummy', 'fax', 'cell2', 'group'] 
2245   
2246 -    def __init__(self, *args, **kwargs): 
2247          dict={} 
2248          # What was supplied to this function 
2249          dict.update(kwargs) 
2250          # Parent constructor 
2251          super(ss_pb_entry,self).__init__(**dict) 
2252          if self.__class__ is ss_pb_entry: 
2253              self._update(args,dict) 
2254   
2255   
2256 -    def getfields(self): 
2257          return self.__fields 
2258   
2259   
2260 -    def _update(self, args, kwargs): 
2261          super(ss_pb_entry,self)._update(args,kwargs) 
2262          keys=kwargs.keys() 
2263          for key in keys: 
2264              if key in self.__fields: 
2265                  setattr(self, key, kwargs[key]) 
2266                  del kwargs[key] 
2267          # Were any unrecognized kwargs passed in? 
2268          if __debug__: 
2269              self._complainaboutunusedargs(ss_pb_entry,kwargs) 
2270          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2271          # Make all P fields that haven't already been constructed 
2272   
2273   
2274 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2275          'Writes this packet to the supplied buffer' 
2276          self._bufferstartoffset=buf.getcurrentoffset() 
2277          self.__field_name.writetobuffer(buf) 
2278          try: self.__field_email 
2279          except: 
2280              self.__field_email=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'default': '',                'maxsizeinbytes': PB_MAX_EMAIL_LEN,                'raiseontruncate': False }) 
2281          self.__field_email.writetobuffer(buf) 
2282          try: self.__field_email2 
2283          except: 
2284              self.__field_email2=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'default': '',                'maxsizeinbytes': PB_MAX_EMAIL_LEN,                'raiseontruncate': False }) 
2285          self.__field_email2.writetobuffer(buf) 
2286          try: self.__field__gen_p_samsungschu740_263 
2287          except: 
2288              self.__field__gen_p_samsungschu740_263=DONTCARE(**{'sizeinbytes': 2}) 
2289          self.__field__gen_p_samsungschu740_263.writetobuffer(buf) 
2290          try: self.__field_note 
2291          except: 
2292              self.__field_note=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'maxsizeinbytes': PB_MAX_NOTE_LEN,                'raiseontruncate': False,                'default': '' }) 
2293          self.__field_note.writetobuffer(buf) 
2294          try: self.__field__gen_p_samsungschu740_269 
2295          except: 
2296              self.__field__gen_p_samsungschu740_269=DONTCARE(**{'sizeinbytes': 1}) 
2297          self.__field__gen_p_samsungschu740_269.writetobuffer(buf) 
2298          try: self.__field_wallpaper 
2299          except: 
2300              self.__field_wallpaper=STRING(**{ 'terminator': 0,               'default': '' }) 
2301          self.__field_wallpaper.writetobuffer(buf) 
2302          try: self.__field_wallpaper_range 
2303          except: 
2304              self.__field_wallpaper_range=UINT(**{'sizeinbytes': 4,  'default': 0 }) 
2305          self.__field_wallpaper_range.writetobuffer(buf) 
2306          try: self.__field__gen_p_samsungschu740_273 
2307          except: 
2308              self.__field__gen_p_samsungschu740_273=DONTCARE(**{'sizeinbytes': 1}) 
2309          self.__field__gen_p_samsungschu740_273.writetobuffer(buf) 
2310          try: self.__field_home 
2311          except: 
2312              self.__field_home=ss_number_entry() 
2313          self.__field_home.writetobuffer(buf) 
2314          try: self.__field_work 
2315          except: 
2316              self.__field_work=ss_number_entry() 
2317          self.__field_work.writetobuffer(buf) 
2318          try: self.__field_cell 
2319          except: 
2320              self.__field_cell=ss_number_entry() 
2321          self.__field_cell.writetobuffer(buf) 
2322          try: self.__field_dummy 
2323          except: 
2324              self.__field_dummy=ss_number_entry() 
2325          self.__field_dummy.writetobuffer(buf) 
2326          try: self.__field_fax 
2327          except: 
2328              self.__field_fax=ss_number_entry() 
2329          self.__field_fax.writetobuffer(buf) 
2330          try: self.__field_cell2 
2331          except: 
2332              self.__field_cell2=ss_number_entry() 
2333          self.__field_cell2.writetobuffer(buf) 
2334          try: self.__field__gen_p_samsungschu740_280 
2335          except: 
2336              self.__field__gen_p_samsungschu740_280=DONTCARE(**{'sizeinbytes': 4}) 
2337          self.__field__gen_p_samsungschu740_280.writetobuffer(buf) 
2338          try: self.__field_group 
2339          except: 
2340              self.__field_group=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
2341          self.__field_group.writetobuffer(buf) 
2342          try: self.__field__gen_p_samsungschu740_282 
2343          except: 
2344              self.__field__gen_p_samsungschu740_282=DONTCARE(**{'sizeinbytes': 2}) 
2345          self.__field__gen_p_samsungschu740_282.writetobuffer(buf) 
2346          self._bufferendoffset=buf.getcurrentoffset() 
2347          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2348   
2349   
2350 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2351          'Reads this packet from the supplied buffer' 
2352          self._bufferstartoffset=buf.getcurrentoffset() 
2353          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2354          self.__field_name=USTRING(**{ 'terminator': 0,                'maxsizeinbytes': PB_MAX_NAME_LEN,                'encoding': ENCODING,                'raiseontruncate': False }) 
2355          self.__field_name.readfrombuffer(buf) 
2356          self.__field_email=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'default': '',                'maxsizeinbytes': PB_MAX_EMAIL_LEN,                'raiseontruncate': False }) 
2357          self.__field_email.readfrombuffer(buf) 
2358          self.__field_email2=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'default': '',                'maxsizeinbytes': PB_MAX_EMAIL_LEN,                'raiseontruncate': False }) 
2359          self.__field_email2.readfrombuffer(buf) 
2360          self.__field__gen_p_samsungschu740_263=DONTCARE(**{'sizeinbytes': 2}) 
2361          self.__field__gen_p_samsungschu740_263.readfrombuffer(buf) 
2362          self.__field_note=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'maxsizeinbytes': PB_MAX_NOTE_LEN,                'raiseontruncate': False,                'default': '' }) 
2363          self.__field_note.readfrombuffer(buf) 
2364          self.__field__gen_p_samsungschu740_269=DONTCARE(**{'sizeinbytes': 1}) 
2365          self.__field__gen_p_samsungschu740_269.readfrombuffer(buf) 
2366          self.__field_wallpaper=STRING(**{ 'terminator': 0,               'default': '' }) 
2367          self.__field_wallpaper.readfrombuffer(buf) 
2368          self.__field_wallpaper_range=UINT(**{'sizeinbytes': 4,  'default': 0 }) 
2369          self.__field_wallpaper_range.readfrombuffer(buf) 
2370          self.__field__gen_p_samsungschu740_273=DONTCARE(**{'sizeinbytes': 1}) 
2371          self.__field__gen_p_samsungschu740_273.readfrombuffer(buf) 
2372          self.__field_home=ss_number_entry() 
2373          self.__field_home.readfrombuffer(buf) 
2374          self.__field_work=ss_number_entry() 
2375          self.__field_work.readfrombuffer(buf) 
2376          self.__field_cell=ss_number_entry() 
2377          self.__field_cell.readfrombuffer(buf) 
2378          self.__field_dummy=ss_number_entry() 
2379          self.__field_dummy.readfrombuffer(buf) 
2380          self.__field_fax=ss_number_entry() 
2381          self.__field_fax.readfrombuffer(buf) 
2382          self.__field_cell2=ss_number_entry() 
2383          self.__field_cell2.readfrombuffer(buf) 
2384          self.__field__gen_p_samsungschu740_280=DONTCARE(**{'sizeinbytes': 4}) 
2385          self.__field__gen_p_samsungschu740_280.readfrombuffer(buf) 
2386          self.__field_group=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
2387          self.__field_group.readfrombuffer(buf) 
2388          self.__field__gen_p_samsungschu740_282=DONTCARE(**{'sizeinbytes': 2}) 
2389          self.__field__gen_p_samsungschu740_282.readfrombuffer(buf) 
2390          self._bufferendoffset=buf.getcurrentoffset() 
2391   
2392   
2393 -    def __getfield_name(self): 
2394          return self.__field_name.getvalue() 
2395   
2396 -    def __setfield_name(self, value): 
2397          if isinstance(value,USTRING): 
2398              self.__field_name=value 
2399          else: 
2400              self.__field_name=USTRING(value,**{ 'terminator': 0,                'maxsizeinbytes': PB_MAX_NAME_LEN,                'encoding': ENCODING,                'raiseontruncate': False }) 
2401   
2402 -    def __delfield_name(self): del self.__field_name 
2403   
2404      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
2405   
2406 -    def __getfield_email(self): 
2407          try: self.__field_email 
2408          except: 
2409              self.__field_email=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'default': '',                'maxsizeinbytes': PB_MAX_EMAIL_LEN,                'raiseontruncate': False }) 
2410          return self.__field_email.getvalue() 
2411   
2412 -    def __setfield_email(self, value): 
2413          if isinstance(value,USTRING): 
2414              self.__field_email=value 
2415          else: 
2416              self.__field_email=USTRING(value,**{ 'terminator': 0,                'encoding': ENCODING,                'default': '',                'maxsizeinbytes': PB_MAX_EMAIL_LEN,                'raiseontruncate': False }) 
2417   
2418 -    def __delfield_email(self): del self.__field_email 
2419   
2420      email=property(__getfield_email, __setfield_email, __delfield_email, None) 
2421   
2422 -    def __getfield_email2(self): 
2423          try: self.__field_email2 
2424          except: 
2425              self.__field_email2=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'default': '',                'maxsizeinbytes': PB_MAX_EMAIL_LEN,                'raiseontruncate': False }) 
2426          return self.__field_email2.getvalue() 
2427   
2428 -    def __setfield_email2(self, value): 
2429          if isinstance(value,USTRING): 
2430              self.__field_email2=value 
2431          else: 
2432              self.__field_email2=USTRING(value,**{ 'terminator': 0,                'encoding': ENCODING,                'default': '',                'maxsizeinbytes': PB_MAX_EMAIL_LEN,                'raiseontruncate': False }) 
2433   
2434 -    def __delfield_email2(self): del self.__field_email2 
2435   
2436      email2=property(__getfield_email2, __setfield_email2, __delfield_email2, None) 
2437   
2438 -    def __getfield_note(self): 
2439          try: self.__field_note 
2440          except: 
2441              self.__field_note=USTRING(**{ 'terminator': 0,                'encoding': ENCODING,                'maxsizeinbytes': PB_MAX_NOTE_LEN,                'raiseontruncate': False,                'default': '' }) 
2442          return self.__field_note.getvalue() 
2443   
2444 -    def __setfield_note(self, value): 
2445          if isinstance(value,USTRING): 
2446              self.__field_note=value 
2447          else: 
2448              self.__field_note=USTRING(value,**{ 'terminator': 0,                'encoding': ENCODING,                'maxsizeinbytes': PB_MAX_NOTE_LEN,                'raiseontruncate': False,                'default': '' }) 
2449   
2450 -    def __delfield_note(self): del self.__field_note 
2451   
2452      note=property(__getfield_note, __setfield_note, __delfield_note, None) 
2453   
2454 -    def __getfield_wallpaper(self): 
2455          try: self.__field_wallpaper 
2456          except: 
2457              self.__field_wallpaper=STRING(**{ 'terminator': 0,               'default': '' }) 
2458          return self.__field_wallpaper.getvalue() 
2459   
2460 -    def __setfield_wallpaper(self, value): 
2461          if isinstance(value,STRING): 
2462              self.__field_wallpaper=value 
2463          else: 
2464              self.__field_wallpaper=STRING(value,**{ 'terminator': 0,               'default': '' }) 
2465   
2466 -    def __delfield_wallpaper(self): del self.__field_wallpaper 
2467   
2468      wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None) 
2469   
2470 -    def __getfield_wallpaper_range(self): 
2471          try: self.__field_wallpaper_range 
2472          except: 
2473              self.__field_wallpaper_range=UINT(**{'sizeinbytes': 4,  'default': 0 }) 
2474          return self.__field_wallpaper_range.getvalue() 
2475   
2476 -    def __setfield_wallpaper_range(self, value): 
2477          if isinstance(value,UINT): 
2478              self.__field_wallpaper_range=value 
2479          else: 
2480              self.__field_wallpaper_range=UINT(value,**{'sizeinbytes': 4,  'default': 0 }) 
2481   
2482 -    def __delfield_wallpaper_range(self): del self.__field_wallpaper_range 
2483   
2484      wallpaper_range=property(__getfield_wallpaper_range, __setfield_wallpaper_range, __delfield_wallpaper_range, None) 
2485   
2486 -    def __getfield_home(self): 
2487          try: self.__field_home 
2488          except: 
2489              self.__field_home=ss_number_entry() 
2490          return self.__field_home.getvalue() 
2491   
2492 -    def __setfield_home(self, value): 
2493          if isinstance(value,ss_number_entry): 
2494              self.__field_home=value 
2495          else: 
2496              self.__field_home=ss_number_entry(value,) 
2497   
2498 -    def __delfield_home(self): del self.__field_home 
2499   
2500      home=property(__getfield_home, __setfield_home, __delfield_home, None) 
2501   
2502 -    def __getfield_work(self): 
2503          try: self.__field_work 
2504          except: 
2505              self.__field_work=ss_number_entry() 
2506          return self.__field_work.getvalue() 
2507   
2508 -    def __setfield_work(self, value): 
2509          if isinstance(value,ss_number_entry): 
2510              self.__field_work=value 
2511          else: 
2512              self.__field_work=ss_number_entry(value,) 
2513   
2514 -    def __delfield_work(self): del self.__field_work 
2515   
2516      work=property(__getfield_work, __setfield_work, __delfield_work, None) 
2517   
2518 -    def __getfield_cell(self): 
2519          try: self.__field_cell 
2520          except: 
2521              self.__field_cell=ss_number_entry() 
2522          return self.__field_cell.getvalue() 
2523   
2524 -    def __setfield_cell(self, value): 
2525          if isinstance(value,ss_number_entry): 
2526              self.__field_cell=value 
2527          else: 
2528              self.__field_cell=ss_number_entry(value,) 
2529   
2530 -    def __delfield_cell(self): del self.__field_cell 
2531   
2532      cell=property(__getfield_cell, __setfield_cell, __delfield_cell, None) 
2533   
2534 -    def __getfield_dummy(self): 
2535          try: self.__field_dummy 
2536          except: 
2537              self.__field_dummy=ss_number_entry() 
2538          return self.__field_dummy.getvalue() 
2539   
2540 -    def __setfield_dummy(self, value): 
2541          if isinstance(value,ss_number_entry): 
2542              self.__field_dummy=value 
2543          else: 
2544              self.__field_dummy=ss_number_entry(value,) 
2545   
2546 -    def __delfield_dummy(self): del self.__field_dummy 
2547   
2548      dummy=property(__getfield_dummy, __setfield_dummy, __delfield_dummy, None) 
2549   
2550 -    def __getfield_fax(self): 
2551          try: self.__field_fax 
2552          except: 
2553              self.__field_fax=ss_number_entry() 
2554          return self.__field_fax.getvalue() 
2555   
2556 -    def __setfield_fax(self, value): 
2557          if isinstance(value,ss_number_entry): 
2558              self.__field_fax=value 
2559          else: 
2560              self.__field_fax=ss_number_entry(value,) 
2561   
2562 -    def __delfield_fax(self): del self.__field_fax 
2563   
2564      fax=property(__getfield_fax, __setfield_fax, __delfield_fax, None) 
2565   
2566 -    def __getfield_cell2(self): 
2567          try: self.__field_cell2 
2568          except: 
2569              self.__field_cell2=ss_number_entry() 
2570          return self.__field_cell2.getvalue() 
2571   
2572 -    def __setfield_cell2(self, value): 
2573          if isinstance(value,ss_number_entry): 
2574              self.__field_cell2=value 
2575          else: 
2576              self.__field_cell2=ss_number_entry(value,) 
2577   
2578 -    def __delfield_cell2(self): del self.__field_cell2 
2579   
2580      cell2=property(__getfield_cell2, __setfield_cell2, __delfield_cell2, None) 
2581   
2582 -    def __getfield_group(self): 
2583          try: self.__field_group 
2584          except: 
2585              self.__field_group=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
2586          return self.__field_group.getvalue() 
2587   
2588 -    def __setfield_group(self, value): 
2589          if isinstance(value,UINT): 
2590              self.__field_group=value 
2591          else: 
2592              self.__field_group=UINT(value,**{'sizeinbytes': 1,  'default': 0 }) 
2593   
2594 -    def __delfield_group(self): del self.__field_group 
2595   
2596      group=property(__getfield_group, __setfield_group, __delfield_group, None) 
2597   
2598 -    def iscontainer(self): 
2599          return True 
2600   
2601 -    def containerelements(self): 
2602          yield ('name', self.__field_name, None) 
2603          yield ('email', self.__field_email, None) 
2604          yield ('email2', self.__field_email2, None) 
2605          yield ('note', self.__field_note, None) 
2606          yield ('wallpaper', self.__field_wallpaper, None) 
2607          yield ('wallpaper_range', self.__field_wallpaper_range, None) 
2608          yield ('home', self.__field_home, None) 
2609          yield ('work', self.__field_work, None) 
2610          yield ('cell', self.__field_cell, None) 
2611          yield ('dummy', self.__field_dummy, None) 
2612          yield ('fax', self.__field_fax, None) 
2613          yield ('cell2', self.__field_cell2, None) 
2614          yield ('group', self.__field_group, None) 
2615   
2616   
2617   
2618   
2619 -class ss_pb_write_req(BaseProtogenClass): 
2620      __fields=['hdr', 'entry'] 
2621   
2622 -    def __init__(self, *args, **kwargs): 
2623          dict={} 
2624          # What was supplied to this function 
2625          dict.update(kwargs) 
2626          # Parent constructor 
2627          super(ss_pb_write_req,self).__init__(**dict) 
2628          if self.__class__ is ss_pb_write_req: 
2629              self._update(args,dict) 
2630   
2631   
2632 -    def getfields(self): 
2633          return self.__fields 
2634   
2635   
2636 -    def _update(self, args, kwargs): 
2637          super(ss_pb_write_req,self)._update(args,kwargs) 
2638          keys=kwargs.keys() 
2639          for key in keys: 
2640              if key in self.__fields: 
2641                  setattr(self, key, kwargs[key]) 
2642                  del kwargs[key] 
2643          # Were any unrecognized kwargs passed in? 
2644          if __debug__: 
2645              self._complainaboutunusedargs(ss_pb_write_req,kwargs) 
2646          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2647          # Make all P fields that haven't already been constructed 
2648   
2649   
2650 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2651          'Writes this packet to the supplied buffer' 
2652          self._bufferstartoffset=buf.getcurrentoffset() 
2653          try: self.__field_hdr 
2654          except: 
2655              self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_WRITE }) 
2656          self.__field_hdr.writetobuffer(buf) 
2657          try: self.__field__gen_p_samsungschu740_286 
2658          except: 
2659              self.__field__gen_p_samsungschu740_286=DONTCARE(**{'sizeinbytes': 1}) 
2660          self.__field__gen_p_samsungschu740_286.writetobuffer(buf) 
2661          self.__field_entry.writetobuffer(buf) 
2662          self._bufferendoffset=buf.getcurrentoffset() 
2663          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2664   
2665   
2666 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2667          'Reads this packet from the supplied buffer' 
2668          self._bufferstartoffset=buf.getcurrentoffset() 
2669          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2670          self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_WRITE }) 
2671          self.__field_hdr.readfrombuffer(buf) 
2672          self.__field__gen_p_samsungschu740_286=DONTCARE(**{'sizeinbytes': 1}) 
2673          self.__field__gen_p_samsungschu740_286.readfrombuffer(buf) 
2674          self.__field_entry=ss_pb_entry() 
2675          self.__field_entry.readfrombuffer(buf) 
2676          self._bufferendoffset=buf.getcurrentoffset() 
2677   
2678   
2679 -    def __getfield_hdr(self): 
2680          try: self.__field_hdr 
2681          except: 
2682              self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_WRITE }) 
2683          return self.__field_hdr.getvalue() 
2684   
2685 -    def __setfield_hdr(self, value): 
2686          if isinstance(value,ss_cmd_hdr): 
2687              self.__field_hdr=value 
2688          else: 
2689              self.__field_hdr=ss_cmd_hdr(value,**{ 'command': SS_CMD_PB_WRITE }) 
2690   
2691 -    def __delfield_hdr(self): del self.__field_hdr 
2692   
2693      hdr=property(__getfield_hdr, __setfield_hdr, __delfield_hdr, None) 
2694   
2695 -    def __getfield_entry(self): 
2696          return self.__field_entry.getvalue() 
2697   
2698 -    def __setfield_entry(self, value): 
2699          if isinstance(value,ss_pb_entry): 
2700              self.__field_entry=value 
2701          else: 
2702              self.__field_entry=ss_pb_entry(value,) 
2703   
2704 -    def __delfield_entry(self): del self.__field_entry 
2705   
2706      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
2707   
2708 -    def iscontainer(self): 
2709          return True 
2710   
2711 -    def containerelements(self): 
2712          yield ('hdr', self.__field_hdr, None) 
2713          yield ('entry', self.__field_entry, None) 
2714   
2715   
2716   
2717   
2718 -class ss_pb_write_resp(BaseProtogenClass): 
2719      # Read-From-Buffer-Only Class 
2720      __fields=['hdr', 'index'] 
2721   
2722 -    def __init__(self, *args, **kwargs): 
2723          dict={} 
2724          # What was supplied to this function 
2725          dict.update(kwargs) 
2726          # Parent constructor 
2727          super(ss_pb_write_resp,self).__init__(**dict) 
2728          if self.__class__ is ss_pb_write_resp: 
2729              self._update(args,dict) 
2730   
2731   
2732 -    def getfields(self): 
2733          return self.__fields 
2734   
2735   
2736 -    def _update(self, args, kwargs): 
2737          super(ss_pb_write_resp,self)._update(args,kwargs) 
2738          keys=kwargs.keys() 
2739          for key in keys: 
2740              if key in self.__fields: 
2741                  setattr(self, key, kwargs[key]) 
2742                  del kwargs[key] 
2743          # Were any unrecognized kwargs passed in? 
2744          if __debug__: 
2745              self._complainaboutunusedargs(ss_pb_write_resp,kwargs) 
2746          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2747          # Make all P fields that haven't already been constructed 
2748   
2749   
2750 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2751          'Writes this packet to the supplied buffer' 
2752          raise NotImplementedError 
2753   
2754   
2755 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2756          'Reads this packet from the supplied buffer' 
2757          self._bufferstartoffset=buf.getcurrentoffset() 
2758          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2759          self.__field_hdr=ss_cmd_hdr() 
2760          self.__field_hdr.readfrombuffer(buf) 
2761          DONTCARE(**{'sizeinbytes': 1}).readfrombuffer(buf) 
2762          self.__field_index=UINT(**{'sizeinbytes': 2}) 
2763          self.__field_index.readfrombuffer(buf) 
2764          self._bufferendoffset=buf.getcurrentoffset() 
2765   
2766   
2767 -    def __getfield_hdr(self): 
2768          return self.__field_hdr.getvalue() 
2769   
2770 -    def __setfield_hdr(self, value): 
2771          if isinstance(value,ss_cmd_hdr): 
2772              self.__field_hdr=value 
2773          else: 
2774              self.__field_hdr=ss_cmd_hdr(value,) 
2775   
2776 -    def __delfield_hdr(self): del self.__field_hdr 
2777   
2778      hdr=property(__getfield_hdr, __setfield_hdr, __delfield_hdr, None) 
2779   
2780 -    def __getfield_index(self): 
2781          return self.__field_index.getvalue() 
2782   
2783 -    def __setfield_index(self, value): 
2784          if isinstance(value,UINT): 
2785              self.__field_index=value 
2786          else: 
2787              self.__field_index=UINT(value,**{'sizeinbytes': 2}) 
2788   
2789 -    def __delfield_index(self): del self.__field_index 
2790   
2791      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
2792   
2793 -    def iscontainer(self): 
2794          return True 
2795   
2796 -    def containerelements(self): 
2797          yield ('hdr', self.__field_hdr, None) 
2798          yield ('index', self.__field_index, None) 
2799   
2800   
2801   
2802   
2803 -class pBOOL(BaseProtogenClass): 
2804      __fields=['value'] 
2805   
2806 -    def __init__(self, *args, **kwargs): 
2807          dict={} 
2808          # What was supplied to this function 
2809          dict.update(kwargs) 
2810          # Parent constructor 
2811          super(pBOOL,self).__init__(**dict) 
2812          if self.__class__ is pBOOL: 
2813              self._update(args,dict) 
2814   
2815   
2816 -    def getfields(self): 
2817          return self.__fields 
2818   
2819   
2820 -    def _update(self, args, kwargs): 
2821          super(pBOOL,self)._update(args,kwargs) 
2822          keys=kwargs.keys() 
2823          for key in keys: 
2824              if key in self.__fields: 
2825                  setattr(self, key, kwargs[key]) 
2826                  del kwargs[key] 
2827          # Were any unrecognized kwargs passed in? 
2828          if __debug__: 
2829              self._complainaboutunusedargs(pBOOL,kwargs) 
2830          if len(args): 
2831              dict2={'sizeinbytes': 'P'} 
2832              dict2.update(kwargs) 
2833              kwargs=dict2 
2834              self.__field_value=BOOL(*args,**dict2) 
2835          # Make all P fields that haven't already been constructed 
2836          try: self.__field_value 
2837          except: 
2838              self.__field_value=BOOL() 
2839   
2840   
2841 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2842          'Writes this packet to the supplied buffer' 
2843          self._bufferstartoffset=buf.getcurrentoffset() 
2844          self._bufferendoffset=buf.getcurrentoffset() 
2845          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2846   
2847   
2848 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2849          'Reads this packet from the supplied buffer' 
2850          self._bufferstartoffset=buf.getcurrentoffset() 
2851          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2852          self._bufferendoffset=buf.getcurrentoffset() 
2853   
2854   
2855 -    def __getfield_value(self): 
2856          return self.__field_value.getvalue() 
2857   
2858 -    def __setfield_value(self, value): 
2859          if isinstance(value,BOOL): 
2860              self.__field_value=value 
2861          else: 
2862              self.__field_value=BOOL(value,) 
2863   
2864 -    def __delfield_value(self): del self.__field_value 
2865   
2866      value=property(__getfield_value, __setfield_value, __delfield_value, None) 
2867   
2868 -    def iscontainer(self): 
2869          return True 
2870   
2871 -    def containerelements(self): 
2872          yield ('value', self.__field_value, None) 
2873   
2874   
2875   
2876   
2877 -class sms_header(BaseProtogenClass): 
2878      # Read-From-Buffer-Only Class 
2879      __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'] 
2880   
2881 -    def __init__(self, *args, **kwargs): 
2882          dict={} 
2883          # What was supplied to this function 
2884          dict.update(kwargs) 
2885          # Parent constructor 
2886          super(sms_header,self).__init__(**dict) 
2887          if self.__class__ is sms_header: 
2888              self._update(args,dict) 
2889   
2890   
2891 -    def getfields(self): 
2892          return self.__fields 
2893   
2894   
2895 -    def _update(self, args, kwargs): 
2896          super(sms_header,self)._update(args,kwargs) 
2897          keys=kwargs.keys() 
2898          for key in keys: 
2899              if key in self.__fields: 
2900                  setattr(self, key, kwargs[key]) 
2901                  del kwargs[key] 
2902          # Were any unrecognized kwargs passed in? 
2903          if __debug__: 
2904              self._complainaboutunusedargs(sms_header,kwargs) 
2905          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2906          # Make all P fields that haven't already been constructed 
2907   
2908   
2909 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2910          'Writes this packet to the supplied buffer' 
2911          raise NotImplementedError 
2912   
2913   
2914 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2915          'Reads this packet from the supplied buffer' 
2916          self._bufferstartoffset=buf.getcurrentoffset() 
2917          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2918          self.__field_index=UINT(**{'sizeinbytes': 2}) 
2919          self.__field_index.readfrombuffer(buf) 
2920          self.__field_msg_len=UINT(**{'sizeinbytes': 1}) 
2921          self.__field_msg_len.readfrombuffer(buf) 
2922          self.__field_callback_len=UINT(**{'sizeinbytes': 1}) 
2923          self.__field_callback_len.readfrombuffer(buf) 
2924          self.__field_bitmap1=UINT(**{'sizeinbytes': 1}) 
2925          self.__field_bitmap1.readfrombuffer(buf) 
2926          self.__field_bitmap2=UINT(**{'sizeinbytes': 1}) 
2927          self.__field_bitmap2.readfrombuffer(buf) 
2928          DONTCARE(**{'sizeinbytes': 6}).readfrombuffer(buf) 
2929          self.__field_body_len=UINT(**{'sizeinbytes': 2}) 
2930          self.__field_body_len.readfrombuffer(buf) 
2931          self.__field_file_type=UINT(**{'sizeinbytes': 2}) 
2932          self.__field_file_type.readfrombuffer(buf) 
2933          self.__field_msg_type=UINT(**{'sizeinbytes': 1}) 
2934          self.__field_msg_type.readfrombuffer(buf) 
2935          self.__field_enhance_delivery=UINT(**{'sizeinbytes': 1}) 
2936          self.__field_enhance_delivery.readfrombuffer(buf) 
2937          self.__field_is_txt_msg=pBOOL(**{ 'value': self.file_type==SMS_TXT_TYPE and self.msg_type in SMS_VALID_TYPE }) 
2938          self.__field_is_txt_msg.readfrombuffer(buf) 
2939          self.__field_in_msg=pBOOL(**{ 'value': self.msg_type==SMS_TYPE_IN }) 
2940          self.__field_in_msg.readfrombuffer(buf) 
2941          self.__field_sent_msg=pBOOL(**{ 'value': self.msg_type==SMS_TYPE_SENT }) 
2942          self.__field_sent_msg.readfrombuffer(buf) 
2943          self.__field_draft_msg=pBOOL(**{ 'value': self.msg_type==SMS_TYPE_DRAFT }) 
2944          self.__field_draft_msg.readfrombuffer(buf) 
2945          if self.is_txt_msg.value: 
2946              self.__field_body=sms_body(**{            'msg_len': self.msg_len,            'has_callback': self.bitmap2 & SMS_FLG2_CALLBACK,            'has_priority': self.bitmap2 & SMS_FLG2_PRIORITY,            'has_1byte': self.bitmap2 & SMS_FLG2_SOMETHING,            'has_1byte2': self.bitmap2 & SMS_FLG2_MSG,            'has_40bytes': self.bitmap1 & SMS_FLG1_HAS40 }) 
2947              self.__field_body.readfrombuffer(buf) 
2948          self._bufferendoffset=buf.getcurrentoffset() 
2949   
2950   
2951 -    def __getfield_index(self): 
2952          return self.__field_index.getvalue() 
2953   
2954 -    def __setfield_index(self, value): 
2955          if isinstance(value,UINT): 
2956              self.__field_index=value 
2957          else: 
2958              self.__field_index=UINT(value,**{'sizeinbytes': 2}) 
2959   
2960 -    def __delfield_index(self): del self.__field_index 
2961   
2962      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
2963   
2964 -    def __getfield_msg_len(self): 
2965          return self.__field_msg_len.getvalue() 
2966   
2967 -    def __setfield_msg_len(self, value): 
2968          if isinstance(value,UINT): 
2969              self.__field_msg_len=value 
2970          else: 
2971              self.__field_msg_len=UINT(value,**{'sizeinbytes': 1}) 
2972   
2973 -    def __delfield_msg_len(self): del self.__field_msg_len 
2974   
2975      msg_len=property(__getfield_msg_len, __setfield_msg_len, __delfield_msg_len, None) 
2976   
2977 -    def __getfield_callback_len(self): 
2978          return self.__field_callback_len.getvalue() 
2979   
2980 -    def __setfield_callback_len(self, value): 
2981          if isinstance(value,UINT): 
2982              self.__field_callback_len=value 
2983          else: 
2984              self.__field_callback_len=UINT(value,**{'sizeinbytes': 1}) 
2985   
2986 -    def __delfield_callback_len(self): del self.__field_callback_len 
2987   
2988      callback_len=property(__getfield_callback_len, __setfield_callback_len, __delfield_callback_len, None) 
2989   
2990 -    def __getfield_bitmap1(self): 
2991          return self.__field_bitmap1.getvalue() 
2992   
2993 -    def __setfield_bitmap1(self, value): 
2994          if isinstance(value,UINT): 
2995              self.__field_bitmap1=value 
2996          else: 
2997              self.__field_bitmap1=UINT(value,**{'sizeinbytes': 1}) 
2998   
2999 -    def __delfield_bitmap1(self): del self.__field_bitmap1 
3000   
3001      bitmap1=property(__getfield_bitmap1, __setfield_bitmap1, __delfield_bitmap1, None) 
3002   
3003 -    def __getfield_bitmap2(self): 
3004          return self.__field_bitmap2.getvalue() 
3005   
3006 -    def __setfield_bitmap2(self, value): 
3007          if isinstance(value,UINT): 
3008              self.__field_bitmap2=value 
3009          else: 
3010              self.__field_bitmap2=UINT(value,**{'sizeinbytes': 1}) 
3011   
3012 -    def __delfield_bitmap2(self): del self.__field_bitmap2 
3013   
3014      bitmap2=property(__getfield_bitmap2, __setfield_bitmap2, __delfield_bitmap2, None) 
3015   
3016 -    def __getfield_body_len(self): 
3017          return self.__field_body_len.getvalue() 
3018   
3019 -    def __setfield_body_len(self, value): 
3020          if isinstance(value,UINT): 
3021              self.__field_body_len=value 
3022          else: 
3023              self.__field_body_len=UINT(value,**{'sizeinbytes': 2}) 
3024   
3025 -    def __delfield_body_len(self): del self.__field_body_len 
3026   
3027      body_len=property(__getfield_body_len, __setfield_body_len, __delfield_body_len, None) 
3028   
3029 -    def __getfield_file_type(self): 
3030          return self.__field_file_type.getvalue() 
3031   
3032 -    def __setfield_file_type(self, value): 
3033          if isinstance(value,UINT): 
3034              self.__field_file_type=value 
3035          else: 
3036              self.__field_file_type=UINT(value,**{'sizeinbytes': 2}) 
3037   
3038 -    def __delfield_file_type(self): del self.__field_file_type 
3039   
3040      file_type=property(__getfield_file_type, __setfield_file_type, __delfield_file_type, None) 
3041   
3042 -    def __getfield_msg_type(self): 
3043          return self.__field_msg_type.getvalue() 
3044   
3045 -    def __setfield_msg_type(self, value): 
3046          if isinstance(value,UINT): 
3047              self.__field_msg_type=value 
3048          else: 
3049              self.__field_msg_type=UINT(value,**{'sizeinbytes': 1}) 
3050   
3051 -    def __delfield_msg_type(self): del self.__field_msg_type 
3052   
3053      msg_type=property(__getfield_msg_type, __setfield_msg_type, __delfield_msg_type, None) 
3054   
3055 -    def __getfield_enhance_delivery(self): 
3056          return self.__field_enhance_delivery.getvalue() 
3057   
3058 -    def __setfield_enhance_delivery(self, value): 
3059          if isinstance(value,UINT): 
3060              self.__field_enhance_delivery=value 
3061          else: 
3062              self.__field_enhance_delivery=UINT(value,**{'sizeinbytes': 1}) 
3063   
3064 -    def __delfield_enhance_delivery(self): del self.__field_enhance_delivery 
3065   
3066      enhance_delivery=property(__getfield_enhance_delivery, __setfield_enhance_delivery, __delfield_enhance_delivery, None) 
3067   
3068 -    def __getfield_is_txt_msg(self): 
3069          return self.__field_is_txt_msg.getvalue() 
3070   
3071 -    def __setfield_is_txt_msg(self, value): 
3072          if isinstance(value,pBOOL): 
3073              self.__field_is_txt_msg=value 
3074          else: 
3075              self.__field_is_txt_msg=pBOOL(value,**{ 'value': self.file_type==SMS_TXT_TYPE and self.msg_type in SMS_VALID_TYPE }) 
3076   
3077 -    def __delfield_is_txt_msg(self): del self.__field_is_txt_msg 
3078   
3079      is_txt_msg=property(__getfield_is_txt_msg, __setfield_is_txt_msg, __delfield_is_txt_msg, None) 
3080   
3081 -    def __getfield_in_msg(self): 
3082          return self.__field_in_msg.getvalue() 
3083   
3084 -    def __setfield_in_msg(self, value): 
3085          if isinstance(value,pBOOL): 
3086              self.__field_in_msg=value 
3087          else: 
3088              self.__field_in_msg=pBOOL(value,**{ 'value': self.msg_type==SMS_TYPE_IN }) 
3089   
3090 -    def __delfield_in_msg(self): del self.__field_in_msg 
3091   
3092      in_msg=property(__getfield_in_msg, __setfield_in_msg, __delfield_in_msg, None) 
3093   
3094 -    def __getfield_sent_msg(self): 
3095          return self.__field_sent_msg.getvalue() 
3096   
3097 -    def __setfield_sent_msg(self, value): 
3098          if isinstance(value,pBOOL): 
3099              self.__field_sent_msg=value 
3100          else: 
3101              self.__field_sent_msg=pBOOL(value,**{ 'value': self.msg_type==SMS_TYPE_SENT }) 
3102   
3103 -    def __delfield_sent_msg(self): del self.__field_sent_msg 
3104   
3105      sent_msg=property(__getfield_sent_msg, __setfield_sent_msg, __delfield_sent_msg, None) 
3106   
3107 -    def __getfield_draft_msg(self): 
3108          return self.__field_draft_msg.getvalue() 
3109   
3110 -    def __setfield_draft_msg(self, value): 
3111          if isinstance(value,pBOOL): 
3112              self.__field_draft_msg=value 
3113          else: 
3114              self.__field_draft_msg=pBOOL(value,**{ 'value': self.msg_type==SMS_TYPE_DRAFT }) 
3115   
3116 -    def __delfield_draft_msg(self): del self.__field_draft_msg 
3117   
3118      draft_msg=property(__getfield_draft_msg, __setfield_draft_msg, __delfield_draft_msg, None) 
3119   
3120 -    def __getfield_body(self): 
3121          return self.__field_body.getvalue() 
3122   
3123 -    def __setfield_body(self, value): 
3124          if isinstance(value,sms_body): 
3125              self.__field_body=value 
3126          else: 
3127              self.__field_body=sms_body(value,**{            'msg_len': self.msg_len,            'has_callback': self.bitmap2 & SMS_FLG2_CALLBACK,            'has_priority': self.bitmap2 & SMS_FLG2_PRIORITY,            'has_1byte': self.bitmap2 & SMS_FLG2_SOMETHING,            'has_1byte2': self.bitmap2 & SMS_FLG2_MSG,            'has_40bytes': self.bitmap1 & SMS_FLG1_HAS40 }) 
3128   
3129 -    def __delfield_body(self): del self.__field_body 
3130   
3131      body=property(__getfield_body, __setfield_body, __delfield_body, None) 
3132   
3133 -    def iscontainer(self): 
3134          return True 
3135   
3136 -    def containerelements(self): 
3137          yield ('index', self.__field_index, None) 
3138          yield ('msg_len', self.__field_msg_len, None) 
3139          yield ('callback_len', self.__field_callback_len, None) 
3140          yield ('bitmap1', self.__field_bitmap1, None) 
3141          yield ('bitmap2', self.__field_bitmap2, None) 
3142          yield ('body_len', self.__field_body_len, None) 
3143          yield ('file_type', self.__field_file_type, None) 
3144          yield ('msg_type', self.__field_msg_type, None) 
3145          yield ('enhance_delivery', self.__field_enhance_delivery, None) 
3146          yield ('is_txt_msg', self.__field_is_txt_msg, None) 
3147          yield ('in_msg', self.__field_in_msg, None) 
3148          yield ('sent_msg', self.__field_sent_msg, None) 
3149          yield ('draft_msg', self.__field_draft_msg, None) 
3150          if self.is_txt_msg.value: 
3151              yield ('body', self.__field_body, None) 
3152   
3153   
3154   
3155   
3156 -class sms_msg_stat_list(BaseProtogenClass): 
3157      # Read-From-Buffer-Only Class 
3158      __fields=['status'] 
3159   
3160 -    def __init__(self, *args, **kwargs): 
3161          dict={} 
3162          # What was supplied to this function 
3163          dict.update(kwargs) 
3164          # Parent constructor 
3165          super(sms_msg_stat_list,self).__init__(**dict) 
3166          if self.__class__ is sms_msg_stat_list: 
3167              self._update(args,dict) 
3168   
3169   
3170 -    def getfields(self): 
3171          return self.__fields 
3172   
3173   
3174 -    def _update(self, args, kwargs): 
3175          super(sms_msg_stat_list,self)._update(args,kwargs) 
3176          keys=kwargs.keys() 
3177          for key in keys: 
3178              if key in self.__fields: 
3179                  setattr(self, key, kwargs[key]) 
3180                  del kwargs[key] 
3181          # Were any unrecognized kwargs passed in? 
3182          if __debug__: 
3183              self._complainaboutunusedargs(sms_msg_stat_list,kwargs) 
3184          if len(args): 
3185              dict2={'sizeinbytes': 1} 
3186              dict2.update(kwargs) 
3187              kwargs=dict2 
3188              self.__field_status=UINT(*args,**dict2) 
3189          # Make all P fields that haven't already been constructed 
3190   
3191   
3192 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3193          'Writes this packet to the supplied buffer' 
3194          raise NotImplementedError 
3195   
3196   
3197 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3198          'Reads this packet from the supplied buffer' 
3199          self._bufferstartoffset=buf.getcurrentoffset() 
3200          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3201          self.__field_status=UINT(**{'sizeinbytes': 1}) 
3202          self.__field_status.readfrombuffer(buf) 
3203          self._bufferendoffset=buf.getcurrentoffset() 
3204   
3205   
3206 -    def __getfield_status(self): 
3207          return self.__field_status.getvalue() 
3208   
3209 -    def __setfield_status(self, value): 
3210          if isinstance(value,UINT): 
3211              self.__field_status=value 
3212          else: 
3213              self.__field_status=UINT(value,**{'sizeinbytes': 1}) 
3214   
3215 -    def __delfield_status(self): del self.__field_status 
3216   
3217      status=property(__getfield_status, __setfield_status, __delfield_status, None) 
3218   
3219 -    def iscontainer(self): 
3220          return True 
3221   
3222 -    def containerelements(self): 
3223          yield ('status', self.__field_status, None) 
3224   
3225   
3226   
3227   
3228 -class sms_datetime_list(BaseProtogenClass): 
3229      # Read-From-Buffer-Only Class 
3230      __fields=['datetime'] 
3231   
3232 -    def __init__(self, *args, **kwargs): 
3233          dict={} 
3234          # What was supplied to this function 
3235          dict.update(kwargs) 
3236          # Parent constructor 
3237          super(sms_datetime_list,self).__init__(**dict) 
3238          if self.__class__ is sms_datetime_list: 
3239              self._update(args,dict) 
3240   
3241   
3242 -    def getfields(self): 
3243          return self.__fields 
3244   
3245   
3246 -    def _update(self, args, kwargs): 
3247          super(sms_datetime_list,self)._update(args,kwargs) 
3248          keys=kwargs.keys() 
3249          for key in keys: 
3250              if key in self.__fields: 
3251                  setattr(self, key, kwargs[key]) 
3252                  del kwargs[key] 
3253          # Were any unrecognized kwargs passed in? 
3254          if __debug__: 
3255              self._complainaboutunusedargs(sms_datetime_list,kwargs) 
3256          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
3257          # Make all P fields that haven't already been constructed 
3258   
3259   
3260 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3261          'Writes this packet to the supplied buffer' 
3262          raise NotImplementedError 
3263   
3264   
3265 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3266          'Reads this packet from the supplied buffer' 
3267          self._bufferstartoffset=buf.getcurrentoffset() 
3268          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3269          self.__field_datetime=DateTime1(**{'sizeinbytes': 4}) 
3270          self.__field_datetime.readfrombuffer(buf) 
3271          DONTCARE(**{'sizeinbytes': 4}).readfrombuffer(buf) 
3272          self._bufferendoffset=buf.getcurrentoffset() 
3273   
3274   
3275 -    def __getfield_datetime(self): 
3276          return self.__field_datetime.getvalue() 
3277   
3278 -    def __setfield_datetime(self, value): 
3279          if isinstance(value,DateTime1): 
3280              self.__field_datetime=value 
3281          else: 
3282              self.__field_datetime=DateTime1(value,**{'sizeinbytes': 4}) 
3283   
3284 -    def __delfield_datetime(self): del self.__field_datetime 
3285   
3286      datetime=property(__getfield_datetime, __setfield_datetime, __delfield_datetime, None) 
3287   
3288 -    def iscontainer(self): 
3289          return True 
3290   
3291 -    def containerelements(self): 
3292          yield ('datetime', self.__field_datetime, None) 
3293   
3294   
3295   
3296   
3297 -class sms_delivered_datetime(BaseProtogenClass): 
3298      # Read-From-Buffer-Only Class 
3299      __fields=['datetime'] 
3300   
3301 -    def __init__(self, *args, **kwargs): 
3302          dict={} 
3303          # What was supplied to this function 
3304          dict.update(kwargs) 
3305          # Parent constructor 
3306          super(sms_delivered_datetime,self).__init__(**dict) 
3307          if self.__class__ is sms_delivered_datetime: 
3308              self._update(args,dict) 
3309   
3310   
3311 -    def getfields(self): 
3312          return self.__fields 
3313   
3314   
3315 -    def _update(self, args, kwargs): 
3316          super(sms_delivered_datetime,self)._update(args,kwargs) 
3317          keys=kwargs.keys() 
3318          for key in keys: 
3319              if key in self.__fields: 
3320                  setattr(self, key, kwargs[key]) 
3321                  del kwargs[key] 
3322          # Were any unrecognized kwargs passed in? 
3323          if __debug__: 
3324              self._complainaboutunusedargs(sms_delivered_datetime,kwargs) 
3325          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
3326          # Make all P fields that haven't already been constructed 
3327   
3328   
3329 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3330          'Writes this packet to the supplied buffer' 
3331          raise NotImplementedError 
3332   
3333   
3334 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3335          'Reads this packet from the supplied buffer' 
3336          self._bufferstartoffset=buf.getcurrentoffset() 
3337          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3338          self.__field_datetime=LIST(**{ 'elementclass': sms_datetime_list,             'length': 10 }) 
3339          self.__field_datetime.readfrombuffer(buf) 
3340          DONTCARE(**{'sizeinbytes': 20}).readfrombuffer(buf) 
3341          self._bufferendoffset=buf.getcurrentoffset() 
3342   
3343   
3344 -    def __getfield_datetime(self): 
3345          return self.__field_datetime.getvalue() 
3346   
3347 -    def __setfield_datetime(self, value): 
3348          if isinstance(value,LIST): 
3349              self.__field_datetime=value 
3350          else: 
3351              self.__field_datetime=LIST(value,**{ 'elementclass': sms_datetime_list,             'length': 10 }) 
3352   
3353 -    def __delfield_datetime(self): del self.__field_datetime 
3354   
3355      datetime=property(__getfield_datetime, __setfield_datetime, __delfield_datetime, None) 
3356   
3357 -    def iscontainer(self): 
3358          return True 
3359   
3360 -    def containerelements(self): 
3361          yield ('datetime', self.__field_datetime, None) 
3362   
3363   
3364   
3365   
3366 -class sms_body(BaseProtogenClass): 
3367      # Read-From-Buffer-Only Class 
3368      __fields=['msg_len', 'has_callback', 'has_priority', 'has_1byte', 'has_1byte2', 'has_40bytes', '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'] 
3369   
3370 -    def __init__(self, *args, **kwargs): 
3371          dict={} 
3372          # What was supplied to this function 
3373          dict.update(kwargs) 
3374          # Parent constructor 
3375          super(sms_body,self).__init__(**dict) 
3376          if self.__class__ is sms_body: 
3377              self._update(args,dict) 
3378   
3379   
3380 -    def getfields(self): 
3381          return self.__fields 
3382   
3383   
3384 -    def _update(self, args, kwargs): 
3385          super(sms_body,self)._update(args,kwargs) 
3386          keys=kwargs.keys() 
3387          for key in keys: 
3388              if key in self.__fields: 
3389                  setattr(self, key, kwargs[key]) 
3390                  del kwargs[key] 
3391          # Were any unrecognized kwargs passed in? 
3392          if __debug__: 
3393              self._complainaboutunusedargs(sms_body,kwargs) 
3394          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
3395          # Make all P fields that haven't already been constructed 
3396          try: self.__field_msg_len 
3397          except: 
3398              self.__field_msg_len=UINT() 
3399          try: self.__field_has_callback 
3400          except: 
3401              self.__field_has_callback=BOOL(**{ 'default': True }) 
3402          try: self.__field_has_priority 
3403          except: 
3404              self.__field_has_priority=BOOL(**{ 'default': False }) 
3405          try: self.__field_has_1byte 
3406          except: 
3407              self.__field_has_1byte=BOOL(**{ 'default': False }) 
3408          try: self.__field_has_1byte2 
3409          except: 
3410              self.__field_has_1byte2=BOOL(**{ 'default': True }) 
3411          try: self.__field_has_40bytes 
3412          except: 
3413              self.__field_has_40bytes=BOOL(**{ 'default': False }) 
3414   
3415   
3416 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3417          'Writes this packet to the supplied buffer' 
3418          raise NotImplementedError 
3419   
3420   
3421 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3422          'Reads this packet from the supplied buffer' 
3423          self._bufferstartoffset=buf.getcurrentoffset() 
3424          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3425          DONTCARE(**{'sizeinbytes': 53}).readfrombuffer(buf) 
3426          self.__field_msg=USTRING(**{ 'sizeinbytes': self.msg_len,                'encoding': ENCODING,                'terminator': None }) 
3427          self.__field_msg.readfrombuffer(buf) 
3428          if self.has_callback: 
3429              DONTCARE(**{'sizeinbytes': 3}).readfrombuffer(buf) 
3430              self.__field_callback_len=UINT(**{'sizeinbytes': 1}) 
3431              self.__field_callback_len.readfrombuffer(buf) 
3432              self.__field_callback=STRING(**{ 'sizeinbytes': self.callback_len,                   'terminator': None }) 
3433              self.__field_callback.readfrombuffer(buf) 
3434          if self.has_priority: 
3435              self.__field_priority=UINT(**{'sizeinbytes': 1}) 
3436              self.__field_priority.readfrombuffer(buf) 
3437          if self.has_1byte: 
3438              DONTCARE(**{'sizeinbytes': 1}).readfrombuffer(buf) 
3439          DONTCARE(**{'sizeinbytes': 40}).readfrombuffer(buf) 
3440          self.__field_datetime=DateTime1(**{'sizeinbytes': 4}) 
3441          self.__field_datetime.readfrombuffer(buf) 
3442          DONTCARE(**{'sizeinbytes': 17}).readfrombuffer(buf) 
3443          self.__field_addr_len0=UINT(**{'sizeinbytes': 1}) 
3444          self.__field_addr_len0.readfrombuffer(buf) 
3445          self.__field_addr_len1=UINT(**{'sizeinbytes': 1}) 
3446          self.__field_addr_len1.readfrombuffer(buf) 
3447          self.__field_addr_len2=UINT(**{'sizeinbytes': 1}) 
3448          self.__field_addr_len2.readfrombuffer(buf) 
3449          self.__field_addr_len3=UINT(**{'sizeinbytes': 1}) 
3450          self.__field_addr_len3.readfrombuffer(buf) 
3451          self.__field_addr_len4=UINT(**{'sizeinbytes': 1}) 
3452          self.__field_addr_len4.readfrombuffer(buf) 
3453          self.__field_addr_len5=UINT(**{'sizeinbytes': 1}) 
3454          self.__field_addr_len5.readfrombuffer(buf) 
3455          self.__field_addr_len6=UINT(**{'sizeinbytes': 1}) 
3456          self.__field_addr_len6.readfrombuffer(buf) 
3457          self.__field_addr_len7=UINT(**{'sizeinbytes': 1}) 
3458          self.__field_addr_len7.readfrombuffer(buf) 
3459          self.__field_addr_len8=UINT(**{'sizeinbytes': 1}) 
3460          self.__field_addr_len8.readfrombuffer(buf) 
3461          self.__field_addr_len9=UINT(**{'sizeinbytes': 1}) 
3462          self.__field_addr_len9.readfrombuffer(buf) 
3463          if self.addr_len0: 
3464              self.__field_addr0=STRING(**{ 'sizeinbytes': self.addr_len0,                   'terminator': None }) 
3465              self.__field_addr0.readfrombuffer(buf) 
3466          if self.addr_len1: 
3467              self.__field_addr1=STRING(**{ 'sizeinbytes': self.addr_len1,                   'terminator': None }) 
3468              self.__field_addr1.readfrombuffer(buf) 
3469          if self.addr_len2: 
3470              self.__field_addr2=STRING(**{ 'sizeinbytes': self.addr_len2,                   'terminator': None }) 
3471              self.__field_addr2.readfrombuffer(buf) 
3472          if self.addr_len3: 
3473              self.__field_addr3=STRING(**{ 'sizeinbytes': self.addr_len3,                   'terminator': None }) 
3474              self.__field_addr3.readfrombuffer(buf) 
3475          if self.addr_len4: 
3476              self.__field_addr4=STRING(**{ 'sizeinbytes': self.addr_len4,                   'terminator': None }) 
3477              self.__field_addr4.readfrombuffer(buf) 
3478          if self.addr_len5: 
3479              self.__field_addr5=STRING(**{ 'sizeinbytes': self.addr_len5,                   'terminator': None }) 
3480              self.__field_addr5.readfrombuffer(buf) 
3481          if self.addr_len6: 
3482              self.__field_addr6=STRING(**{ 'sizeinbytes': self.addr_len6,                   'terminator': None }) 
3483              self.__field_addr6.readfrombuffer(buf) 
3484          if self.addr_len7: 
3485              self.__field_addr7=STRING(**{ 'sizeinbytes': self.addr_len7,                   'terminator': None }) 
3486              self.__field_addr7.readfrombuffer(buf) 
3487          if self.addr_len8: 
3488              self.__field_addr8=STRING(**{ 'sizeinbytes': self.addr_len8,                   'terminator': None }) 
3489              self.__field_addr8.readfrombuffer(buf) 
3490          if self.addr_len9: 
3491              self.__field_addr9=STRING(**{ 'sizeinbytes': self.addr_len9,                   'terminator': None }) 
3492              self.__field_addr9.readfrombuffer(buf) 
3493          if not self.has_1byte and self.has_1byte2: 
3494              DONTCARE(**{'sizeinbytes': 1}).readfrombuffer(buf) 
3495          if self.has_1byte2: 
3496              DONTCARE(**{'sizeinbytes': 1}).readfrombuffer(buf) 
3497          DONTCARE(**{'sizeinbytes': 81}).readfrombuffer(buf) 
3498          if self.has_40bytes: 
3499              DONTCARE(**{'sizeinbytes': 40}).readfrombuffer(buf) 
3500          self.__field_msg_stat=LIST(**{ 'elementclass': sms_msg_stat_list,             'length': 10 }) 
3501          self.__field_msg_stat.readfrombuffer(buf) 
3502          self._bufferendoffset=buf.getcurrentoffset() 
3503   
3504   
3505 -    def __getfield_msg_len(self): 
3506          return self.__field_msg_len.getvalue() 
3507   
3508 -    def __setfield_msg_len(self, value): 
3509          if isinstance(value,UINT): 
3510              self.__field_msg_len=value 
3511          else: 
3512              self.__field_msg_len=UINT(value,) 
3513   
3514 -    def __delfield_msg_len(self): del self.__field_msg_len 
3515   
3516      msg_len=property(__getfield_msg_len, __setfield_msg_len, __delfield_msg_len, None) 
3517   
3518 -    def __getfield_has_callback(self): 
3519          try: self.__field_has_callback 
3520          except: 
3521              self.__field_has_callback=BOOL(**{ 'default': True }) 
3522          return self.__field_has_callback.getvalue() 
3523   
3524 -    def __setfield_has_callback(self, value): 
3525          if isinstance(value,BOOL): 
3526              self.__field_has_callback=value 
3527          else: 
3528              self.__field_has_callback=BOOL(value,**{ 'default': True }) 
3529   
3530 -    def __delfield_has_callback(self): del self.__field_has_callback 
3531   
3532      has_callback=property(__getfield_has_callback, __setfield_has_callback, __delfield_has_callback, None) 
3533   
3534 -    def __getfield_has_priority(self): 
3535          try: self.__field_has_priority 
3536          except: 
3537              self.__field_has_priority=BOOL(**{ 'default': False }) 
3538          return self.__field_has_priority.getvalue() 
3539   
3540 -    def __setfield_has_priority(self, value): 
3541          if isinstance(value,BOOL): 
3542              self.__field_has_priority=value 
3543          else: 
3544              self.__field_has_priority=BOOL(value,**{ 'default': False }) 
3545   
3546 -    def __delfield_has_priority(self): del self.__field_has_priority 
3547   
3548      has_priority=property(__getfield_has_priority, __setfield_has_priority, __delfield_has_priority, None) 
3549   
3550 -    def __getfield_has_1byte(self): 
3551          try: self.__field_has_1byte 
3552          except: 
3553              self.__field_has_1byte=BOOL(**{ 'default': False }) 
3554          return self.__field_has_1byte.getvalue() 
3555   
3556 -    def __setfield_has_1byte(self, value): 
3557          if isinstance(value,BOOL): 
3558              self.__field_has_1byte=value 
3559          else: 
3560              self.__field_has_1byte=BOOL(value,**{ 'default': False }) 
3561   
3562 -    def __delfield_has_1byte(self): del self.__field_has_1byte 
3563   
3564      has_1byte=property(__getfield_has_1byte, __setfield_has_1byte, __delfield_has_1byte, None) 
3565   
3566 -    def __getfield_has_1byte2(self): 
3567          try: self.__field_has_1byte2 
3568          except: 
3569              self.__field_has_1byte2=BOOL(**{ 'default': True }) 
3570          return self.__field_has_1byte2.getvalue() 
3571   
3572 -    def __setfield_has_1byte2(self, value): 
3573          if isinstance(value,BOOL): 
3574              self.__field_has_1byte2=value 
3575          else: 
3576              self.__field_has_1byte2=BOOL(value,**{ 'default': True }) 
3577   
3578 -    def __delfield_has_1byte2(self): del self.__field_has_1byte2 
3579   
3580      has_1byte2=property(__getfield_has_1byte2, __setfield_has_1byte2, __delfield_has_1byte2, None) 
3581   
3582 -    def __getfield_has_40bytes(self): 
3583          try: self.__field_has_40bytes 
3584          except: 
3585              self.__field_has_40bytes=BOOL(**{ 'default': False }) 
3586          return self.__field_has_40bytes.getvalue() 
3587   
3588 -    def __setfield_has_40bytes(self, value): 
3589          if isinstance(value,BOOL): 
3590              self.__field_has_40bytes=value 
3591          else: 
3592              self.__field_has_40bytes=BOOL(value,**{ 'default': False }) 
3593   
3594 -    def __delfield_has_40bytes(self): del self.__field_has_40bytes 
3595   
3596      has_40bytes=property(__getfield_has_40bytes, __setfield_has_40bytes, __delfield_has_40bytes, None) 
3597   
3598 -    def __getfield_msg(self): 
3599          return self.__field_msg.getvalue() 
3600   
3601 -    def __setfield_msg(self, value): 
3602          if isinstance(value,USTRING): 
3603              self.__field_msg=value 
3604          else: 
3605              self.__field_msg=USTRING(value,**{ 'sizeinbytes': self.msg_len,                'encoding': ENCODING,                'terminator': None }) 
3606   
3607 -    def __delfield_msg(self): del self.__field_msg 
3608   
3609      msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None) 
3610   
3611 -    def __getfield_callback_len(self): 
3612          return self.__field_callback_len.getvalue() 
3613   
3614 -    def __setfield_callback_len(self, value): 
3615          if isinstance(value,UINT): 
3616              self.__field_callback_len=value 
3617          else: 
3618              self.__field_callback_len=UINT(value,**{'sizeinbytes': 1}) 
3619   
3620 -    def __delfield_callback_len(self): del self.__field_callback_len 
3621   
3622      callback_len=property(__getfield_callback_len, __setfield_callback_len, __delfield_callback_len, None) 
3623   
3624 -    def __getfield_callback(self): 
3625          return self.__field_callback.getvalue() 
3626   
3627 -    def __setfield_callback(self, value): 
3628          if isinstance(value,STRING): 
3629              self.__field_callback=value 
3630          else: 
3631              self.__field_callback=STRING(value,**{ 'sizeinbytes': self.callback_len,                   'terminator': None }) 
3632   
3633 -    def __delfield_callback(self): del self.__field_callback 
3634   
3635      callback=property(__getfield_callback, __setfield_callback, __delfield_callback, None) 
3636   
3637 -    def __getfield_priority(self): 
3638          return self.__field_priority.getvalue() 
3639   
3640 -    def __setfield_priority(self, value): 
3641          if isinstance(value,UINT): 
3642              self.__field_priority=value 
3643          else: 
3644              self.__field_priority=UINT(value,**{'sizeinbytes': 1}) 
3645   
3646 -    def __delfield_priority(self): del self.__field_priority 
3647   
3648      priority=property(__getfield_priority, __setfield_priority, __delfield_priority, None) 
3649   
3650 -    def __getfield_datetime(self): 
3651          return self.__field_datetime.getvalue() 
3652   
3653 -    def __setfield_datetime(self, value): 
3654          if isinstance(value,DateTime1): 
3655              self.__field_datetime=value 
3656          else: 
3657              self.__field_datetime=DateTime1(value,**{'sizeinbytes': 4}) 
3658   
3659 -    def __delfield_datetime(self): del self.__field_datetime 
3660   
3661      datetime=property(__getfield_datetime, __setfield_datetime, __delfield_datetime, None) 
3662   
3663 -    def __getfield_addr_len0(self): 
3664          return self.__field_addr_len0.getvalue() 
3665   
3666 -    def __setfield_addr_len0(self, value): 
3667          if isinstance(value,UINT): 
3668              self.__field_addr_len0=value 
3669          else: 
3670              self.__field_addr_len0=UINT(value,**{'sizeinbytes': 1}) 
3671   
3672 -    def __delfield_addr_len0(self): del self.__field_addr_len0 
3673   
3674      addr_len0=property(__getfield_addr_len0, __setfield_addr_len0, __delfield_addr_len0, None) 
3675   
3676 -    def __getfield_addr_len1(self): 
3677          return self.__field_addr_len1.getvalue() 
3678   
3679 -    def __setfield_addr_len1(self, value): 
3680          if isinstance(value,UINT): 
3681              self.__field_addr_len1=value 
3682          else: 
3683              self.__field_addr_len1=UINT(value,**{'sizeinbytes': 1}) 
3684   
3685 -    def __delfield_addr_len1(self): del self.__field_addr_len1 
3686   
3687      addr_len1=property(__getfield_addr_len1, __setfield_addr_len1, __delfield_addr_len1, None) 
3688   
3689 -    def __getfield_addr_len2(self): 
3690          return self.__field_addr_len2.getvalue() 
3691   
3692 -    def __setfield_addr_len2(self, value): 
3693          if isinstance(value,UINT): 
3694              self.__field_addr_len2=value 
3695          else: 
3696              self.__field_addr_len2=UINT(value,**{'sizeinbytes': 1}) 
3697   
3698 -    def __delfield_addr_len2(self): del self.__field_addr_len2 
3699   
3700      addr_len2=property(__getfield_addr_len2, __setfield_addr_len2, __delfield_addr_len2, None) 
3701   
3702 -    def __getfield_addr_len3(self): 
3703          return self.__field_addr_len3.getvalue() 
3704   
3705 -    def __setfield_addr_len3(self, value): 
3706          if isinstance(value,UINT): 
3707              self.__field_addr_len3=value 
3708          else: 
3709              self.__field_addr_len3=UINT(value,**{'sizeinbytes': 1}) 
3710   
3711 -    def __delfield_addr_len3(self): del self.__field_addr_len3 
3712   
3713      addr_len3=property(__getfield_addr_len3, __setfield_addr_len3, __delfield_addr_len3, None) 
3714   
3715 -    def __getfield_addr_len4(self): 
3716          return self.__field_addr_len4.getvalue() 
3717   
3718 -    def __setfield_addr_len4(self, value): 
3719          if isinstance(value,UINT): 
3720              self.__field_addr_len4=value 
3721          else: 
3722              self.__field_addr_len4=UINT(value,**{'sizeinbytes': 1}) 
3723   
3724 -    def __delfield_addr_len4(self): del self.__field_addr_len4 
3725   
3726      addr_len4=property(__getfield_addr_len4, __setfield_addr_len4, __delfield_addr_len4, None) 
3727   
3728 -    def __getfield_addr_len5(self): 
3729          return self.__field_addr_len5.getvalue() 
3730   
3731 -    def __setfield_addr_len5(self, value): 
3732          if isinstance(value,UINT): 
3733              self.__field_addr_len5=value 
3734          else: 
3735              self.__field_addr_len5=UINT(value,**{'sizeinbytes': 1}) 
3736   
3737 -    def __delfield_addr_len5(self): del self.__field_addr_len5 
3738   
3739      addr_len5=property(__getfield_addr_len5, __setfield_addr_len5, __delfield_addr_len5, None) 
3740   
3741 -    def __getfield_addr_len6(self): 
3742          return self.__field_addr_len6.getvalue() 
3743   
3744 -    def __setfield_addr_len6(self, value): 
3745          if isinstance(value,UINT): 
3746              self.__field_addr_len6=value 
3747          else: 
3748              self.__field_addr_len6=UINT(value,**{'sizeinbytes': 1}) 
3749   
3750 -    def __delfield_addr_len6(self): del self.__field_addr_len6 
3751   
3752      addr_len6=property(__getfield_addr_len6, __setfield_addr_len6, __delfield_addr_len6, None) 
3753   
3754 -    def __getfield_addr_len7(self): 
3755          return self.__field_addr_len7.getvalue() 
3756   
3757 -    def __setfield_addr_len7(self, value): 
3758          if isinstance(value,UINT): 
3759              self.__field_addr_len7=value 
3760          else: 
3761              self.__field_addr_len7=UINT(value,**{'sizeinbytes': 1}) 
3762   
3763 -    def __delfield_addr_len7(self): del self.__field_addr_len7 
3764   
3765      addr_len7=property(__getfield_addr_len7, __setfield_addr_len7, __delfield_addr_len7, None) 
3766   
3767 -    def __getfield_addr_len8(self): 
3768          return self.__field_addr_len8.getvalue() 
3769   
3770 -    def __setfield_addr_len8(self, value): 
3771          if isinstance(value,UINT): 
3772              self.__field_addr_len8=value 
3773          else: 
3774              self.__field_addr_len8=UINT(value,**{'sizeinbytes': 1}) 
3775   
3776 -    def __delfield_addr_len8(self): del self.__field_addr_len8 
3777   
3778      addr_len8=property(__getfield_addr_len8, __setfield_addr_len8, __delfield_addr_len8, None) 
3779   
3780 -    def __getfield_addr_len9(self): 
3781          return self.__field_addr_len9.getvalue() 
3782   
3783 -    def __setfield_addr_len9(self, value): 
3784          if isinstance(value,UINT): 
3785              self.__field_addr_len9=value 
3786          else: 
3787              self.__field_addr_len9=UINT(value,**{'sizeinbytes': 1}) 
3788   
3789 -    def __delfield_addr_len9(self): del self.__field_addr_len9 
3790   
3791      addr_len9=property(__getfield_addr_len9, __setfield_addr_len9, __delfield_addr_len9, None) 
3792   
3793 -    def __getfield_addr0(self): 
3794          return self.__field_addr0.getvalue() 
3795   
3796 -    def __setfield_addr0(self, value): 
3797          if isinstance(value,STRING): 
3798              self.__field_addr0=value 
3799          else: 
3800              self.__field_addr0=STRING(value,**{ 'sizeinbytes': self.addr_len0,                   'terminator': None }) 
3801   
3802 -    def __delfield_addr0(self): del self.__field_addr0 
3803   
3804      addr0=property(__getfield_addr0, __setfield_addr0, __delfield_addr0, None) 
3805   
3806 -    def __getfield_addr1(self): 
3807          return self.__field_addr1.getvalue() 
3808   
3809 -    def __setfield_addr1(self, value): 
3810          if isinstance(value,STRING): 
3811              self.__field_addr1=value 
3812          else: 
3813              self.__field_addr1=STRING(value,**{ 'sizeinbytes': self.addr_len1,                   'terminator': None }) 
3814   
3815 -    def __delfield_addr1(self): del self.__field_addr1 
3816   
3817      addr1=property(__getfield_addr1, __setfield_addr1, __delfield_addr1, None) 
3818   
3819 -    def __getfield_addr2(self): 
3820          return self.__field_addr2.getvalue() 
3821   
3822 -    def __setfield_addr2(self, value): 
3823          if isinstance(value,STRING): 
3824              self.__field_addr2=value 
3825          else: 
3826              self.__field_addr2=STRING(value,**{ 'sizeinbytes': self.addr_len2,                   'terminator': None }) 
3827   
3828 -    def __delfield_addr2(self): del self.__field_addr2 
3829   
3830      addr2=property(__getfield_addr2, __setfield_addr2, __delfield_addr2, None) 
3831   
3832 -    def __getfield_addr3(self): 
3833          return self.__field_addr3.getvalue() 
3834   
3835 -    def __setfield_addr3(self, value): 
3836          if isinstance(value,STRING): 
3837              self.__field_addr3=value 
3838          else: 
3839              self.__field_addr3=STRING(value,**{ 'sizeinbytes': self.addr_len3,                   'terminator': None }) 
3840   
3841 -    def __delfield_addr3(self): del self.__field_addr3 
3842   
3843      addr3=property(__getfield_addr3, __setfield_addr3, __delfield_addr3, None) 
3844   
3845 -    def __getfield_addr4(self): 
3846          return self.__field_addr4.getvalue() 
3847   
3848 -    def __setfield_addr4(self, value): 
3849          if isinstance(value,STRING): 
3850              self.__field_addr4=value 
3851          else: 
3852              self.__field_addr4=STRING(value,**{ 'sizeinbytes': self.addr_len4,                   'terminator': None }) 
3853   
3854 -    def __delfield_addr4(self): del self.__field_addr4 
3855   
3856      addr4=property(__getfield_addr4, __setfield_addr4, __delfield_addr4, None) 
3857   
3858 -    def __getfield_addr5(self): 
3859          return self.__field_addr5.getvalue() 
3860   
3861 -    def __setfield_addr5(self, value): 
3862          if isinstance(value,STRING): 
3863              self.__field_addr5=value 
3864          else: 
3865              self.__field_addr5=STRING(value,**{ 'sizeinbytes': self.addr_len5,                   'terminator': None }) 
3866   
3867 -    def __delfield_addr5(self): del self.__field_addr5 
3868   
3869      addr5=property(__getfield_addr5, __setfield_addr5, __delfield_addr5, None) 
3870   
3871 -    def __getfield_addr6(self): 
3872          return self.__field_addr6.getvalue() 
3873   
3874 -    def __setfield_addr6(self, value): 
3875          if isinstance(value,STRING): 
3876              self.__field_addr6=value 
3877          else: 
3878              self.__field_addr6=STRING(value,**{ 'sizeinbytes': self.addr_len6,                   'terminator': None }) 
3879   
3880 -    def __delfield_addr6(self): del self.__field_addr6 
3881   
3882      addr6=property(__getfield_addr6, __setfield_addr6, __delfield_addr6, None) 
3883   
3884 -    def __getfield_addr7(self): 
3885          return self.__field_addr7.getvalue() 
3886   
3887 -    def __setfield_addr7(self, value): 
3888          if isinstance(value,STRING): 
3889              self.__field_addr7=value 
3890          else: 
3891              self.__field_addr7=STRING(value,**{ 'sizeinbytes': self.addr_len7,                   'terminator': None }) 
3892   
3893 -    def __delfield_addr7(self): del self.__field_addr7 
3894   
3895      addr7=property(__getfield_addr7, __setfield_addr7, __delfield_addr7, None) 
3896   
3897 -    def __getfield_addr8(self): 
3898          return self.__field_addr8.getvalue() 
3899   
3900 -    def __setfield_addr8(self, value): 
3901          if isinstance(value,STRING): 
3902              self.__field_addr8=value 
3903          else: 
3904              self.__field_addr8=STRING(value,**{ 'sizeinbytes': self.addr_len8,                   'terminator': None }) 
3905   
3906 -    def __delfield_addr8(self): del self.__field_addr8 
3907   
3908      addr8=property(__getfield_addr8, __setfield_addr8, __delfield_addr8, None) 
3909   
3910 -    def __getfield_addr9(self): 
3911          return self.__field_addr9.getvalue() 
3912   
3913 -    def __setfield_addr9(self, value): 
3914          if isinstance(value,STRING): 
3915              self.__field_addr9=value 
3916          else: 
3917              self.__field_addr9=STRING(value,**{ 'sizeinbytes': self.addr_len9,                   'terminator': None }) 
3918   
3919 -    def __delfield_addr9(self): del self.__field_addr9 
3920   
3921      addr9=property(__getfield_addr9, __setfield_addr9, __delfield_addr9, None) 
3922   
3923 -    def __getfield_msg_stat(self): 
3924          return self.__field_msg_stat.getvalue() 
3925   
3926 -    def __setfield_msg_stat(self, value): 
3927          if isinstance(value,LIST): 
3928              self.__field_msg_stat=value 
3929          else: 
3930              self.__field_msg_stat=LIST(value,**{ 'elementclass': sms_msg_stat_list,             'length': 10 }) 
3931   
3932 -    def __delfield_msg_stat(self): del self.__field_msg_stat 
3933   
3934      msg_stat=property(__getfield_msg_stat, __setfield_msg_stat, __delfield_msg_stat, None) 
3935   
3936 -    def iscontainer(self): 
3937          return True 
3938   
3939 -    def containerelements(self): 
3940          yield ('msg_len', self.__field_msg_len, None) 
3941          yield ('has_callback', self.__field_has_callback, None) 
3942          yield ('has_priority', self.__field_has_priority, None) 
3943          yield ('has_1byte', self.__field_has_1byte, None) 
3944          yield ('has_1byte2', self.__field_has_1byte2, None) 
3945          yield ('has_40bytes', self.__field_has_40bytes, None) 
3946          yield ('msg', self.__field_msg, None) 
3947          if self.has_callback: 
3948              yield ('callback_len', self.__field_callback_len, None) 
3949              yield ('callback', self.__field_callback, None) 
3950          if self.has_priority: 
3951              yield ('priority', self.__field_priority, None) 
3952          if self.has_1byte: 
3953              pass 
3954          yield ('datetime', self.__field_datetime, None) 
3955          yield ('addr_len0', self.__field_addr_len0, None) 
3956          yield ('addr_len1', self.__field_addr_len1, None) 
3957          yield ('addr_len2', self.__field_addr_len2, None) 
3958          yield ('addr_len3', self.__field_addr_len3, None) 
3959          yield ('addr_len4', self.__field_addr_len4, None) 
3960          yield ('addr_len5', self.__field_addr_len5, None) 
3961          yield ('addr_len6', self.__field_addr_len6, None) 
3962          yield ('addr_len7', self.__field_addr_len7, None) 
3963          yield ('addr_len8', self.__field_addr_len8, None) 
3964          yield ('addr_len9', self.__field_addr_len9, None) 
3965          if self.addr_len0: 
3966              yield ('addr0', self.__field_addr0, None) 
3967          if self.addr_len1: 
3968              yield ('addr1', self.__field_addr1, None) 
3969          if self.addr_len2: 
3970              yield ('addr2', self.__field_addr2, None) 
3971          if self.addr_len3: 
3972              yield ('addr3', self.__field_addr3, None) 
3973          if self.addr_len4: 
3974              yield ('addr4', self.__field_addr4, None) 
3975          if self.addr_len5: 
3976              yield ('addr5', self.__field_addr5, None) 
3977          if self.addr_len6: 
3978              yield ('addr6', self.__field_addr6, None) 
3979          if self.addr_len7: 
3980              yield ('addr7', self.__field_addr7, None) 
3981          if self.addr_len8: 
3982              yield ('addr8', self.__field_addr8, None) 
3983          if self.addr_len9: 
3984              yield ('addr9', self.__field_addr9, None) 
3985          if not self.has_1byte and self.has_1byte2: 
3986              pass 
3987          if self.has_1byte2: 
3988              pass 
3989          if self.has_40bytes: 
3990              pass 
3991          yield ('msg_stat', self.__field_msg_stat, None) 
3992   
3993   
3994   
3995   
3996 -class cl_list(BaseProtogenClass): 
3997      # Read-From-Buffer-Only Class 
3998      __fields=['index'] 
3999   
4000 -    def __init__(self, *args, **kwargs): 
4001          dict={} 
4002          # What was supplied to this function 
4003          dict.update(kwargs) 
4004          # Parent constructor 
4005          super(cl_list,self).__init__(**dict) 
4006          if self.__class__ is cl_list: 
4007              self._update(args,dict) 
4008   
4009   
4010 -    def getfields(self): 
4011          return self.__fields 
4012   
4013   
4014 -    def _update(self, args, kwargs): 
4015          super(cl_list,self)._update(args,kwargs) 
4016          keys=kwargs.keys() 
4017          for key in keys: 
4018              if key in self.__fields: 
4019                  setattr(self, key, kwargs[key]) 
4020                  del kwargs[key] 
4021          # Were any unrecognized kwargs passed in? 
4022          if __debug__: 
4023              self._complainaboutunusedargs(cl_list,kwargs) 
4024          if len(args): 
4025              dict2={'sizeinbytes': 2} 
4026              dict2.update(kwargs) 
4027              kwargs=dict2 
4028              self.__field_index=UINT(*args,**dict2) 
4029          # Make all P fields that haven't already been constructed 
4030   
4031   
4032 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
4033          'Writes this packet to the supplied buffer' 
4034          raise NotImplementedError 
4035   
4036   
4037 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
4038          'Reads this packet from the supplied buffer' 
4039          self._bufferstartoffset=buf.getcurrentoffset() 
4040          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
4041          self.__field_index=UINT(**{'sizeinbytes': 2}) 
4042          self.__field_index.readfrombuffer(buf) 
4043          self._bufferendoffset=buf.getcurrentoffset() 
4044   
4045   
4046 -    def __getfield_index(self): 
4047          return self.__field_index.getvalue() 
4048   
4049 -    def __setfield_index(self, value): 
4050          if isinstance(value,UINT): 
4051              self.__field_index=value 
4052          else: 
4053              self.__field_index=UINT(value,**{'sizeinbytes': 2}) 
4054   
4055 -    def __delfield_index(self): del self.__field_index 
4056   
4057      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
4058   
4059 -    def iscontainer(self): 
4060          return True 
4061   
4062 -    def containerelements(self): 
4063          yield ('index', self.__field_index, None) 
4064   
4065   
4066   
4067   
4068 -class cl_index_file(BaseProtogenClass): 
4069      # Read-From-Buffer-Only Class 
4070      __fields=['incoming', 'outgoing', 'missed', 'incoming_count', 'outgoing_count', 'missed_count'] 
4071   
4072 -    def __init__(self, *args, **kwargs): 
4073          dict={} 
4074          # What was supplied to this function 
4075          dict.update(kwargs) 
4076          # Parent constructor 
4077          super(cl_index_file,self).__init__(**dict) 
4078          if self.__class__ is cl_index_file: 
4079              self._update(args,dict) 
4080   
4081   
4082 -    def getfields(self): 
4083          return self.__fields 
4084   
4085   
4086 -    def _update(self, args, kwargs): 
4087          super(cl_index_file,self)._update(args,kwargs) 
4088          keys=kwargs.keys() 
4089          for key in keys: 
4090              if key in self.__fields: 
4091                  setattr(self, key, kwargs[key]) 
4092                  del kwargs[key] 
4093          # Were any unrecognized kwargs passed in? 
4094          if __debug__: 
4095              self._complainaboutunusedargs(cl_index_file,kwargs) 
4096          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
4097          # Make all P fields that haven't already been constructed 
4098   
4099   
4100 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
4101          'Writes this packet to the supplied buffer' 
4102          raise NotImplementedError 
4103   
4104   
4105 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
4106          'Reads this packet from the supplied buffer' 
4107          self._bufferstartoffset=buf.getcurrentoffset() 
4108          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
4109          self.__field_incoming=LIST(**{ 'length': CL_MAX_ENTRIES,             'elementclass': cl_list }) 
4110          self.__field_incoming.readfrombuffer(buf) 
4111          self.__field_outgoing=LIST(**{ 'length': CL_MAX_ENTRIES,             'elementclass': cl_list }) 
4112          self.__field_outgoing.readfrombuffer(buf) 
4113          self.__field_missed=LIST(**{ 'length': CL_MAX_ENTRIES,             'elementclass': cl_list }) 
4114          self.__field_missed.readfrombuffer(buf) 
4115          DONTCARE(**{'sizeinbytes': 992}).readfrombuffer(buf) 
4116          self.__field_incoming_count=UINT(**{'sizeinbytes': 4}) 
4117          self.__field_incoming_count.readfrombuffer(buf) 
4118          self.__field_outgoing_count=UINT(**{'sizeinbytes': 4}) 
4119          self.__field_outgoing_count.readfrombuffer(buf) 
4120          self.__field_missed_count=UINT(**{'sizeinbytes': 4}) 
4121          self.__field_missed_count.readfrombuffer(buf) 
4122          self._bufferendoffset=buf.getcurrentoffset() 
4123   
4124   
4125 -    def __getfield_incoming(self): 
4126          return self.__field_incoming.getvalue() 
4127   
4128 -    def __setfield_incoming(self, value): 
4129          if isinstance(value,LIST): 
4130              self.__field_incoming=value 
4131          else: 
4132              self.__field_incoming=LIST(value,**{ 'length': CL_MAX_ENTRIES,             'elementclass': cl_list }) 
4133   
4134 -    def __delfield_incoming(self): del self.__field_incoming 
4135   
4136      incoming=property(__getfield_incoming, __setfield_incoming, __delfield_incoming, None) 
4137   
4138 -    def __getfield_outgoing(self): 
4139          return self.__field_outgoing.getvalue() 
4140   
4141 -    def __setfield_outgoing(self, value): 
4142          if isinstance(value,LIST): 
4143              self.__field_outgoing=value 
4144          else: 
4145              self.__field_outgoing=LIST(value,**{ 'length': CL_MAX_ENTRIES,             'elementclass': cl_list }) 
4146   
4147 -    def __delfield_outgoing(self): del self.__field_outgoing 
4148   
4149      outgoing=property(__getfield_outgoing, __setfield_outgoing, __delfield_outgoing, None) 
4150   
4151 -    def __getfield_missed(self): 
4152          return self.__field_missed.getvalue() 
4153   
4154 -    def __setfield_missed(self, value): 
4155          if isinstance(value,LIST): 
4156              self.__field_missed=value 
4157          else: 
4158              self.__field_missed=LIST(value,**{ 'length': CL_MAX_ENTRIES,             'elementclass': cl_list }) 
4159   
4160 -    def __delfield_missed(self): del self.__field_missed 
4161   
4162      missed=property(__getfield_missed, __setfield_missed, __delfield_missed, None) 
4163   
4164 -    def __getfield_incoming_count(self): 
4165          return self.__field_incoming_count.getvalue() 
4166   
4167 -    def __setfield_incoming_count(self, value): 
4168          if isinstance(value,UINT): 
4169              self.__field_incoming_count=value 
4170          else: 
4171              self.__field_incoming_count=UINT(value,**{'sizeinbytes': 4}) 
4172   
4173 -    def __delfield_incoming_count(self): del self.__field_incoming_count 
4174   
4175      incoming_count=property(__getfield_incoming_count, __setfield_incoming_count, __delfield_incoming_count, None) 
4176   
4177 -    def __getfield_outgoing_count(self): 
4178          return self.__field_outgoing_count.getvalue() 
4179   
4180 -    def __setfield_outgoing_count(self, value): 
4181          if isinstance(value,UINT): 
4182              self.__field_outgoing_count=value 
4183          else: 
4184              self.__field_outgoing_count=UINT(value,**{'sizeinbytes': 4}) 
4185   
4186 -    def __delfield_outgoing_count(self): del self.__field_outgoing_count 
4187   
4188      outgoing_count=property(__getfield_outgoing_count, __setfield_outgoing_count, __delfield_outgoing_count, None) 
4189   
4190 -    def __getfield_missed_count(self): 
4191          return self.__field_missed_count.getvalue() 
4192   
4193 -    def __setfield_missed_count(self, value): 
4194          if isinstance(value,UINT): 
4195              self.__field_missed_count=value 
4196          else: 
4197              self.__field_missed_count=UINT(value,**{'sizeinbytes': 4}) 
4198   
4199 -    def __delfield_missed_count(self): del self.__field_missed_count 
4200   
4201      missed_count=property(__getfield_missed_count, __setfield_missed_count, __delfield_missed_count, None) 
4202   
4203 -    def iscontainer(self): 
4204          return True 
4205   
4206 -    def containerelements(self): 
4207          yield ('incoming', self.__field_incoming, None) 
4208          yield ('outgoing', self.__field_outgoing, None) 
4209          yield ('missed', self.__field_missed, None) 
4210          yield ('incoming_count', self.__field_incoming_count, None) 
4211          yield ('outgoing_count', self.__field_outgoing_count, None) 
4212          yield ('missed_count', self.__field_missed_count, None) 
4213   
4214   
4215   
4216   
4217 -class cl_file(BaseProtogenClass): 
4218      # Read-From-Buffer-Only Class 
4219      __fields=['cl_type', 'number', 'datetime', 'duration'] 
4220   
4221 -    def __init__(self, *args, **kwargs): 
4222          dict={} 
4223          # What was supplied to this function 
4224          dict.update(kwargs) 
4225          # Parent constructor 
4226          super(cl_file,self).__init__(**dict) 
4227          if self.__class__ is cl_file: 
4228              self._update(args,dict) 
4229   
4230   
4231 -    def getfields(self): 
4232          return self.__fields 
4233   
4234   
4235 -    def _update(self, args, kwargs): 
4236          super(cl_file,self)._update(args,kwargs) 
4237          keys=kwargs.keys() 
4238          for key in keys: 
4239              if key in self.__fields: 
4240                  setattr(self, key, kwargs[key]) 
4241                  del kwargs[key] 
4242          # Were any unrecognized kwargs passed in? 
4243          if __debug__: 
4244              self._complainaboutunusedargs(cl_file,kwargs) 
4245          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
4246          # Make all P fields that haven't already been constructed 
4247   
4248   
4249 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
4250          'Writes this packet to the supplied buffer' 
4251          raise NotImplementedError 
4252   
4253   
4254 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
4255          'Reads this packet from the supplied buffer' 
4256          self._bufferstartoffset=buf.getcurrentoffset() 
4257          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
4258          self.__field_cl_type=UINT(**{'sizeinbytes': 1}) 
4259          self.__field_cl_type.readfrombuffer(buf) 
4260          self.__field_number=STRING(**{'sizeinbytes': 51,  'terminator': 0 }) 
4261          self.__field_number.readfrombuffer(buf) 
4262          self.__field_datetime=DateTime1(**{'sizeinbytes': 4}) 
4263          self.__field_datetime.readfrombuffer(buf) 
4264          DONTCARE(**{'sizeinbytes': 4}).readfrombuffer(buf) 
4265          self.__field_duration=UINT(**{'sizeinbytes': 4}) 
4266          self.__field_duration.readfrombuffer(buf) 
4267          self._bufferendoffset=buf.getcurrentoffset() 
4268   
4269   
4270 -    def __getfield_cl_type(self): 
4271          return self.__field_cl_type.getvalue() 
4272   
4273 -    def __setfield_cl_type(self, value): 
4274          if isinstance(value,UINT): 
4275              self.__field_cl_type=value 
4276          else: 
4277              self.__field_cl_type=UINT(value,**{'sizeinbytes': 1}) 
4278   
4279 -    def __delfield_cl_type(self): del self.__field_cl_type 
4280   
4281      cl_type=property(__getfield_cl_type, __setfield_cl_type, __delfield_cl_type, None) 
4282   
4283 -    def __getfield_number(self): 
4284          return self.__field_number.getvalue() 
4285   
4286 -    def __setfield_number(self, value): 
4287          if isinstance(value,STRING): 
4288              self.__field_number=value 
4289          else: 
4290              self.__field_number=STRING(value,**{'sizeinbytes': 51,  'terminator': 0 }) 
4291   
4292 -    def __delfield_number(self): del self.__field_number 
4293   
4294      number=property(__getfield_number, __setfield_number, __delfield_number, None) 
4295   
4296 -    def __getfield_datetime(self): 
4297          return self.__field_datetime.getvalue() 
4298   
4299 -    def __setfield_datetime(self, value): 
4300          if isinstance(value,DateTime1): 
4301              self.__field_datetime=value 
4302          else: 
4303              self.__field_datetime=DateTime1(value,**{'sizeinbytes': 4}) 
4304   
4305 -    def __delfield_datetime(self): del self.__field_datetime 
4306   
4307      datetime=property(__getfield_datetime, __setfield_datetime, __delfield_datetime, None) 
4308   
4309 -    def __getfield_duration(self): 
4310          return self.__field_duration.getvalue() 
4311   
4312 -    def __setfield_duration(self, value): 
4313          if isinstance(value,UINT): 
4314              self.__field_duration=value 
4315          else: 
4316              self.__field_duration=UINT(value,**{'sizeinbytes': 4}) 
4317   
4318 -    def __delfield_duration(self): del self.__field_duration 
4319   
4320      duration=property(__getfield_duration, __setfield_duration, __delfield_duration, None) 
4321   
4322 -    def iscontainer(self): 
4323          return True 
4324   
4325 -    def containerelements(self): 
4326          yield ('cl_type', self.__field_cl_type, None) 
4327          yield ('number', self.__field_number, None) 
4328          yield ('datetime', self.__field_datetime, None) 
4329          yield ('duration', self.__field_duration, None) 
4330   
4331      @property 
4332 -    def valid(self): 
4333          global CL_VALID_TYPE 
4334          return bool(self.cl_type in CL_VALID_TYPE and self.number) 
4335