Source Code for Module phones.p_samsungscha870

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