Source Code for Module phones.p_samsungschu470

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