Source Code for Module phones.p_sanyo4930

   1  # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE 
   2   
   3  """Various descriptions of data specific to Sanyo RL-4930""" 
   4   
   5  from prototypes import * 
   6   
   7  # Make all sanyo stuff available in this module as well 
   8  from p_sanyo import * 
   9  from p_sanyomedia import * 
  10  from p_sanyonewer import * 
  11   
  12  # We use LSB for all integer like fields 
  13  UINT=UINTlsb 
  14  BOOL=BOOLlsb 
  15  _NUMPBSLOTS=500 
  16  _NUMSPEEDDIALS=8 
  17  _NUMLONGNUMBERS=5 
  18  _LONGPHONENUMBERLEN=30 
  19  _NUMEVENTSLOTS=100 
  20  _NUMCALLALARMSLOTS=15 
  21  _NUMCALLHISTORY=20 
  22  _MAXNUMBERLEN=32 
  23  _MAXEMAILLEN=96 
  24  HASRINGPICBUF=0 
  25    
  26 -class qcpheader(BaseProtogenClass): 
  27      __fields=['readwrite', 'command', 'packettype'] 
  28   
  29 -    def __init__(self, *args, **kwargs): 
  30          dict={} 
  31          # User specified arguments in the packet description 
  32          dict.update({'readwrite': 0x26}) 
  33          # What was supplied to this function 
  34          dict.update(kwargs) 
  35          # Parent constructor 
  36          super(qcpheader,self).__init__(**dict) 
  37          if self.__class__ is qcpheader: 
  38              self._update(args,dict) 
  39   
  40   
  41 -    def getfields(self): 
  42          return self.__fields 
  43   
  44   
  45 -    def _update(self, args, kwargs): 
  46          super(qcpheader,self)._update(args,kwargs) 
  47          keys=kwargs.keys() 
  48          for key in keys: 
  49              if key in self.__fields: 
  50                  setattr(self, key, kwargs[key]) 
  51                  del kwargs[key] 
  52          # Were any unrecognized kwargs passed in? 
  53          if __debug__: 
  54              self._complainaboutunusedargs(qcpheader,kwargs) 
  55          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
  56          # Make all P fields that haven't already been constructed 
  57   
  58   
  59 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
  60          'Writes this packet to the supplied buffer' 
  61          self._bufferstartoffset=buf.getcurrentoffset() 
  62          self.__field_readwrite.writetobuffer(buf) 
  63          self.__field_command.writetobuffer(buf) 
  64          self.__field_packettype.writetobuffer(buf) 
  65          self._bufferendoffset=buf.getcurrentoffset() 
  66          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
  67   
  68   
  69 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
  70          'Reads this packet from the supplied buffer' 
  71          self._bufferstartoffset=buf.getcurrentoffset() 
  72          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
  73          self.__field_readwrite=UINT(**{'sizeinbytes': 1}) 
  74          self.__field_readwrite.readfrombuffer(buf) 
  75          self.__field_command=UINT(**{'sizeinbytes': 1}) 
  76          self.__field_command.readfrombuffer(buf) 
  77          self.__field_packettype=UINT(**{'sizeinbytes': 1}) 
  78          self.__field_packettype.readfrombuffer(buf) 
  79          self._bufferendoffset=buf.getcurrentoffset() 
  80   
  81   
  82 -    def __getfield_readwrite(self): 
  83          return self.__field_readwrite.getvalue() 
  84   
  85 -    def __setfield_readwrite(self, value): 
  86          if isinstance(value,UINT): 
  87              self.__field_readwrite=value 
  88          else: 
  89              self.__field_readwrite=UINT(value,**{'sizeinbytes': 1}) 
  90   
  91 -    def __delfield_readwrite(self): del self.__field_readwrite 
  92   
  93      readwrite=property(__getfield_readwrite, __setfield_readwrite, __delfield_readwrite, None) 
  94   
  95 -    def __getfield_command(self): 
  96          return self.__field_command.getvalue() 
  97   
  98 -    def __setfield_command(self, value): 
  99          if isinstance(value,UINT): 
 100              self.__field_command=value 
 101          else: 
 102              self.__field_command=UINT(value,**{'sizeinbytes': 1}) 
 103   
 104 -    def __delfield_command(self): del self.__field_command 
 105   
 106      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
 107   
 108 -    def __getfield_packettype(self): 
 109          return self.__field_packettype.getvalue() 
 110   
 111 -    def __setfield_packettype(self, value): 
 112          if isinstance(value,UINT): 
 113              self.__field_packettype=value 
 114          else: 
 115              self.__field_packettype=UINT(value,**{'sizeinbytes': 1}) 
 116   
 117 -    def __delfield_packettype(self): del self.__field_packettype 
 118   
 119      packettype=property(__getfield_packettype, __setfield_packettype, __delfield_packettype, None) 
 120   
 121 -    def iscontainer(self): 
 122          return True 
 123   
 124 -    def containerelements(self): 
 125          yield ('readwrite', self.__field_readwrite, None) 
 126          yield ('command', self.__field_command, None) 
 127          yield ('packettype', self.__field_packettype, None) 
 128   
 129   
 130   
 131   
 132 -class qcpwriteheader(BaseProtogenClass): 
 133      __fields=['readwrite', 'command', 'packettype'] 
 134   
 135 -    def __init__(self, *args, **kwargs): 
 136          dict={} 
 137          # User specified arguments in the packet description 
 138          dict.update({'readwrite': 0x27}) 
 139          # What was supplied to this function 
 140          dict.update(kwargs) 
 141          # Parent constructor 
 142          super(qcpwriteheader,self).__init__(**dict) 
 143          if self.__class__ is qcpwriteheader: 
 144              self._update(args,dict) 
 145   
 146   
 147 -    def getfields(self): 
 148          return self.__fields 
 149   
 150   
 151 -    def _update(self, args, kwargs): 
 152          super(qcpwriteheader,self)._update(args,kwargs) 
 153          keys=kwargs.keys() 
 154          for key in keys: 
 155              if key in self.__fields: 
 156                  setattr(self, key, kwargs[key]) 
 157                  del kwargs[key] 
 158          # Were any unrecognized kwargs passed in? 
 159          if __debug__: 
 160              self._complainaboutunusedargs(qcpwriteheader,kwargs) 
 161          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 162          # Make all P fields that haven't already been constructed 
 163   
 164   
 165 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 166          'Writes this packet to the supplied buffer' 
 167          self._bufferstartoffset=buf.getcurrentoffset() 
 168          self.__field_readwrite.writetobuffer(buf) 
 169          self.__field_command.writetobuffer(buf) 
 170          self.__field_packettype.writetobuffer(buf) 
 171          self._bufferendoffset=buf.getcurrentoffset() 
 172          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 173   
 174   
 175 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 176          'Reads this packet from the supplied buffer' 
 177          self._bufferstartoffset=buf.getcurrentoffset() 
 178          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 179          self.__field_readwrite=UINT(**{'sizeinbytes': 1}) 
 180          self.__field_readwrite.readfrombuffer(buf) 
 181          self.__field_command=UINT(**{'sizeinbytes': 1}) 
 182          self.__field_command.readfrombuffer(buf) 
 183          self.__field_packettype=UINT(**{'sizeinbytes': 1}) 
 184          self.__field_packettype.readfrombuffer(buf) 
 185          self._bufferendoffset=buf.getcurrentoffset() 
 186   
 187   
 188 -    def __getfield_readwrite(self): 
 189          return self.__field_readwrite.getvalue() 
 190   
 191 -    def __setfield_readwrite(self, value): 
 192          if isinstance(value,UINT): 
 193              self.__field_readwrite=value 
 194          else: 
 195              self.__field_readwrite=UINT(value,**{'sizeinbytes': 1}) 
 196   
 197 -    def __delfield_readwrite(self): del self.__field_readwrite 
 198   
 199      readwrite=property(__getfield_readwrite, __setfield_readwrite, __delfield_readwrite, None) 
 200   
 201 -    def __getfield_command(self): 
 202          return self.__field_command.getvalue() 
 203   
 204 -    def __setfield_command(self, value): 
 205          if isinstance(value,UINT): 
 206              self.__field_command=value 
 207          else: 
 208              self.__field_command=UINT(value,**{'sizeinbytes': 1}) 
 209   
 210 -    def __delfield_command(self): del self.__field_command 
 211   
 212      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
 213   
 214 -    def __getfield_packettype(self): 
 215          return self.__field_packettype.getvalue() 
 216   
 217 -    def __setfield_packettype(self, value): 
 218          if isinstance(value,UINT): 
 219              self.__field_packettype=value 
 220          else: 
 221              self.__field_packettype=UINT(value,**{'sizeinbytes': 1}) 
 222   
 223 -    def __delfield_packettype(self): del self.__field_packettype 
 224   
 225      packettype=property(__getfield_packettype, __setfield_packettype, __delfield_packettype, None) 
 226   
 227 -    def iscontainer(self): 
 228          return True 
 229   
 230 -    def containerelements(self): 
 231          yield ('readwrite', self.__field_readwrite, None) 
 232          yield ('command', self.__field_command, None) 
 233          yield ('packettype', self.__field_packettype, None) 
 234   
 235   
 236   
 237   
 238 -class pbsortbuffer(BaseProtogenClass): 
 239      "Various arrays for sorting the phone book, speed dial, determining which" 
 240      __fields=['startcommand', 'bufsize', 'comment', 'usedflags', 'slotsused', 'slotsused2', 'numemail', 'numurl', 'firsttypes', 'sortorder', 'pbfirstletters', 'sortorder2', 'speeddialindex', 'longnumbersindex', 'emails', 'emailfirstletters', 'urls', 'urlfirstletters', 'pad'] 
 241   
 242 -    def __init__(self, *args, **kwargs): 
 243          dict={} 
 244          # What was supplied to this function 
 245          dict.update(kwargs) 
 246          # Parent constructor 
 247          super(pbsortbuffer,self).__init__(**dict) 
 248          if self.__class__ is pbsortbuffer: 
 249              self._update(args,dict) 
 250   
 251   
 252 -    def getfields(self): 
 253          return self.__fields 
 254   
 255   
 256 -    def _update(self, args, kwargs): 
 257          super(pbsortbuffer,self)._update(args,kwargs) 
 258          keys=kwargs.keys() 
 259          for key in keys: 
 260              if key in self.__fields: 
 261                  setattr(self, key, kwargs[key]) 
 262                  del kwargs[key] 
 263          # Were any unrecognized kwargs passed in? 
 264          if __debug__: 
 265              self._complainaboutunusedargs(pbsortbuffer,kwargs) 
 266          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 267          # Make all P fields that haven't already been constructed 
 268          try: self.__field_startcommand 
 269          except: 
 270              self.__field_startcommand=UINT(**{'constant': 0x3c}) 
 271          try: self.__field_bufsize 
 272          except: 
 273              self.__field_bufsize=UINT(**{'constant': 7168}) 
 274          try: self.__field_comment 
 275          except: 
 276              self.__field_comment=USTRING(**{'default': "sort buffer"}) 
 277   
 278   
 279 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 280          'Writes this packet to the supplied buffer' 
 281          self._bufferstartoffset=buf.getcurrentoffset() 
 282          try: self.__field_usedflags 
 283          except: 
 284              self.__field_usedflags=LIST(**{'elementclass': _gen_p_sanyo4930_57, 'length': _NUMPBSLOTS, 'createdefault': True}) 
 285          self.__field_usedflags.writetobuffer(buf) 
 286          self.__field_slotsused.writetobuffer(buf) 
 287          self.__field_slotsused2.writetobuffer(buf) 
 288          self.__field_numemail.writetobuffer(buf) 
 289          self.__field_numurl.writetobuffer(buf) 
 290          try: self.__field_firsttypes 
 291          except: 
 292              self.__field_firsttypes=LIST(**{'elementclass': _gen_p_sanyo4930_63, 'length': _NUMPBSLOTS}) 
 293          self.__field_firsttypes.writetobuffer(buf) 
 294          try: self.__field_sortorder 
 295          except: 
 296              self.__field_sortorder=LIST(**{'elementclass': _gen_p_sanyo4930_65, 'length': _NUMPBSLOTS}) 
 297          self.__field_sortorder.writetobuffer(buf) 
 298          self.__field_pbfirstletters.writetobuffer(buf) 
 299          try: self.__field_sortorder2 
 300          except: 
 301              self.__field_sortorder2=LIST(**{'elementclass': _gen_p_sanyo4930_68, 'length': _NUMPBSLOTS}) 
 302          self.__field_sortorder2.writetobuffer(buf) 
 303          try: self.__field_speeddialindex 
 304          except: 
 305              self.__field_speeddialindex=LIST(**{'elementclass': _gen_p_sanyo4930_70, 'length': _NUMSPEEDDIALS}) 
 306          self.__field_speeddialindex.writetobuffer(buf) 
 307          try: self.__field_longnumbersindex 
 308          except: 
 309              self.__field_longnumbersindex=LIST(**{'elementclass': _gen_p_sanyo4930_72, 'length': _NUMLONGNUMBERS}) 
 310          self.__field_longnumbersindex.writetobuffer(buf) 
 311          try: self.__field_emails 
 312          except: 
 313              self.__field_emails=LIST(**{'elementclass': _gen_p_sanyo4930_74, 'length': _NUMPBSLOTS}) 
 314          self.__field_emails.writetobuffer(buf) 
 315          self.__field_emailfirstletters.writetobuffer(buf) 
 316          try: self.__field_urls 
 317          except: 
 318              self.__field_urls=LIST(**{'elementclass': _gen_p_sanyo4930_77, 'length': _NUMPBSLOTS}) 
 319          self.__field_urls.writetobuffer(buf) 
 320          self.__field_urlfirstletters.writetobuffer(buf) 
 321          try: self.__field_pad 
 322          except: 
 323              self.__field_pad=UNKNOWN() 
 324          self.__field_pad.writetobuffer(buf) 
 325          self._bufferendoffset=buf.getcurrentoffset() 
 326          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 327   
 328   
 329 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 330          'Reads this packet from the supplied buffer' 
 331          self._bufferstartoffset=buf.getcurrentoffset() 
 332          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 333          self.__field_usedflags=LIST(**{'elementclass': _gen_p_sanyo4930_57, 'length': _NUMPBSLOTS, 'createdefault': True}) 
 334          self.__field_usedflags.readfrombuffer(buf) 
 335          self.__field_slotsused=UINT(**{'sizeinbytes': 2}) 
 336          self.__field_slotsused.readfrombuffer(buf) 
 337          self.__field_slotsused2=UINT(**{'sizeinbytes': 2}) 
 338          self.__field_slotsused2.readfrombuffer(buf) 
 339          self.__field_numemail=UINT(**{'sizeinbytes': 2}) 
 340          self.__field_numemail.readfrombuffer(buf) 
 341          self.__field_numurl=UINT(**{'sizeinbytes': 2}) 
 342          self.__field_numurl.readfrombuffer(buf) 
 343          self.__field_firsttypes=LIST(**{'elementclass': _gen_p_sanyo4930_63, 'length': _NUMPBSLOTS}) 
 344          self.__field_firsttypes.readfrombuffer(buf) 
 345          self.__field_sortorder=LIST(**{'elementclass': _gen_p_sanyo4930_65, 'length': _NUMPBSLOTS}) 
 346          self.__field_sortorder.readfrombuffer(buf) 
 347          self.__field_pbfirstletters=USTRING(**{'terminator': None, 'sizeinbytes': _NUMPBSLOTS}) 
 348          self.__field_pbfirstletters.readfrombuffer(buf) 
 349          self.__field_sortorder2=LIST(**{'elementclass': _gen_p_sanyo4930_68, 'length': _NUMPBSLOTS}) 
 350          self.__field_sortorder2.readfrombuffer(buf) 
 351          self.__field_speeddialindex=LIST(**{'elementclass': _gen_p_sanyo4930_70, 'length': _NUMSPEEDDIALS}) 
 352          self.__field_speeddialindex.readfrombuffer(buf) 
 353          self.__field_longnumbersindex=LIST(**{'elementclass': _gen_p_sanyo4930_72, 'length': _NUMLONGNUMBERS}) 
 354          self.__field_longnumbersindex.readfrombuffer(buf) 
 355          self.__field_emails=LIST(**{'elementclass': _gen_p_sanyo4930_74, 'length': _NUMPBSLOTS}) 
 356          self.__field_emails.readfrombuffer(buf) 
 357          self.__field_emailfirstletters=USTRING(**{'terminator': None, 'sizeinbytes': _NUMPBSLOTS}) 
 358          self.__field_emailfirstletters.readfrombuffer(buf) 
 359          self.__field_urls=LIST(**{'elementclass': _gen_p_sanyo4930_77, 'length': _NUMPBSLOTS}) 
 360          self.__field_urls.readfrombuffer(buf) 
 361          self.__field_urlfirstletters=USTRING(**{'terminator': None, 'sizeinbytes': _NUMPBSLOTS}) 
 362          self.__field_urlfirstletters.readfrombuffer(buf) 
 363          self.__field_pad=UNKNOWN() 
 364          self.__field_pad.readfrombuffer(buf) 
 365          self._bufferendoffset=buf.getcurrentoffset() 
 366   
 367   
 368 -    def __getfield_startcommand(self): 
 369          return self.__field_startcommand.getvalue() 
 370   
 371 -    def __setfield_startcommand(self, value): 
 372          if isinstance(value,UINT): 
 373              self.__field_startcommand=value 
 374          else: 
 375              self.__field_startcommand=UINT(value,**{'constant': 0x3c}) 
 376   
 377 -    def __delfield_startcommand(self): del self.__field_startcommand 
 378   
 379      startcommand=property(__getfield_startcommand, __setfield_startcommand, __delfield_startcommand, "Starting command for R/W buf parts") 
 380   
 381 -    def __getfield_bufsize(self): 
 382          return self.__field_bufsize.getvalue() 
 383   
 384 -    def __setfield_bufsize(self, value): 
 385          if isinstance(value,UINT): 
 386              self.__field_bufsize=value 
 387          else: 
 388              self.__field_bufsize=UINT(value,**{'constant': 7168}) 
 389   
 390 -    def __delfield_bufsize(self): del self.__field_bufsize 
 391   
 392      bufsize=property(__getfield_bufsize, __setfield_bufsize, __delfield_bufsize, None) 
 393   
 394 -    def __getfield_comment(self): 
 395          try: self.__field_comment 
 396          except: 
 397              self.__field_comment=USTRING(**{'default': "sort buffer"}) 
 398          return self.__field_comment.getvalue() 
 399   
 400 -    def __setfield_comment(self, value): 
 401          if isinstance(value,USTRING): 
 402              self.__field_comment=value 
 403          else: 
 404              self.__field_comment=USTRING(value,**{'default': "sort buffer"}) 
 405   
 406 -    def __delfield_comment(self): del self.__field_comment 
 407   
 408      comment=property(__getfield_comment, __setfield_comment, __delfield_comment, None) 
 409   
 410 -    def __getfield_usedflags(self): 
 411          try: self.__field_usedflags 
 412          except: 
 413              self.__field_usedflags=LIST(**{'elementclass': _gen_p_sanyo4930_57, 'length': _NUMPBSLOTS, 'createdefault': True}) 
 414          return self.__field_usedflags.getvalue() 
 415   
 416 -    def __setfield_usedflags(self, value): 
 417          if isinstance(value,LIST): 
 418              self.__field_usedflags=value 
 419          else: 
 420              self.__field_usedflags=LIST(value,**{'elementclass': _gen_p_sanyo4930_57, 'length': _NUMPBSLOTS, 'createdefault': True}) 
 421   
 422 -    def __delfield_usedflags(self): del self.__field_usedflags 
 423   
 424      usedflags=property(__getfield_usedflags, __setfield_usedflags, __delfield_usedflags, None) 
 425   
 426 -    def __getfield_slotsused(self): 
 427          return self.__field_slotsused.getvalue() 
 428   
 429 -    def __setfield_slotsused(self, value): 
 430          if isinstance(value,UINT): 
 431              self.__field_slotsused=value 
 432          else: 
 433              self.__field_slotsused=UINT(value,**{'sizeinbytes': 2}) 
 434   
 435 -    def __delfield_slotsused(self): del self.__field_slotsused 
 436   
 437      slotsused=property(__getfield_slotsused, __setfield_slotsused, __delfield_slotsused, None) 
 438   
 439 -    def __getfield_slotsused2(self): 
 440          return self.__field_slotsused2.getvalue() 
 441   
 442 -    def __setfield_slotsused2(self, value): 
 443          if isinstance(value,UINT): 
 444              self.__field_slotsused2=value 
 445          else: 
 446              self.__field_slotsused2=UINT(value,**{'sizeinbytes': 2}) 
 447   
 448 -    def __delfield_slotsused2(self): del self.__field_slotsused2 
 449   
 450      slotsused2=property(__getfield_slotsused2, __setfield_slotsused2, __delfield_slotsused2, "Always seems to be the same.  Why duplicated?") 
 451   
 452 -    def __getfield_numemail(self): 
 453          return self.__field_numemail.getvalue() 
 454   
 455 -    def __setfield_numemail(self, value): 
 456          if isinstance(value,UINT): 
 457              self.__field_numemail=value 
 458          else: 
 459              self.__field_numemail=UINT(value,**{'sizeinbytes': 2}) 
 460   
 461 -    def __delfield_numemail(self): del self.__field_numemail 
 462   
 463      numemail=property(__getfield_numemail, __setfield_numemail, __delfield_numemail, "Num of slots with email") 
 464   
 465 -    def __getfield_numurl(self): 
 466          return self.__field_numurl.getvalue() 
 467   
 468 -    def __setfield_numurl(self, value): 
 469          if isinstance(value,UINT): 
 470              self.__field_numurl=value 
 471          else: 
 472              self.__field_numurl=UINT(value,**{'sizeinbytes': 2}) 
 473   
 474 -    def __delfield_numurl(self): del self.__field_numurl 
 475   
 476      numurl=property(__getfield_numurl, __setfield_numurl, __delfield_numurl, "Num of slots with URL") 
 477   
 478 -    def __getfield_firsttypes(self): 
 479          try: self.__field_firsttypes 
 480          except: 
 481              self.__field_firsttypes=LIST(**{'elementclass': _gen_p_sanyo4930_63, 'length': _NUMPBSLOTS}) 
 482          return self.__field_firsttypes.getvalue() 
 483   
 484 -    def __setfield_firsttypes(self, value): 
 485          if isinstance(value,LIST): 
 486              self.__field_firsttypes=value 
 487          else: 
 488              self.__field_firsttypes=LIST(value,**{'elementclass': _gen_p_sanyo4930_63, 'length': _NUMPBSLOTS}) 
 489   
 490 -    def __delfield_firsttypes(self): del self.__field_firsttypes 
 491   
 492      firsttypes=property(__getfield_firsttypes, __setfield_firsttypes, __delfield_firsttypes, None) 
 493   
 494 -    def __getfield_sortorder(self): 
 495          try: self.__field_sortorder 
 496          except: 
 497              self.__field_sortorder=LIST(**{'elementclass': _gen_p_sanyo4930_65, 'length': _NUMPBSLOTS}) 
 498          return self.__field_sortorder.getvalue() 
 499   
 500 -    def __setfield_sortorder(self, value): 
 501          if isinstance(value,LIST): 
 502              self.__field_sortorder=value 
 503          else: 
 504              self.__field_sortorder=LIST(value,**{'elementclass': _gen_p_sanyo4930_65, 'length': _NUMPBSLOTS}) 
 505   
 506 -    def __delfield_sortorder(self): del self.__field_sortorder 
 507   
 508      sortorder=property(__getfield_sortorder, __setfield_sortorder, __delfield_sortorder, None) 
 509   
 510 -    def __getfield_pbfirstletters(self): 
 511          return self.__field_pbfirstletters.getvalue() 
 512   
 513 -    def __setfield_pbfirstletters(self, value): 
 514          if isinstance(value,USTRING): 
 515              self.__field_pbfirstletters=value 
 516          else: 
 517              self.__field_pbfirstletters=USTRING(value,**{'terminator': None, 'sizeinbytes': _NUMPBSLOTS}) 
 518   
 519 -    def __delfield_pbfirstletters(self): del self.__field_pbfirstletters 
 520   
 521      pbfirstletters=property(__getfield_pbfirstletters, __setfield_pbfirstletters, __delfield_pbfirstletters, None) 
 522   
 523 -    def __getfield_sortorder2(self): 
 524          try: self.__field_sortorder2 
 525          except: 
 526              self.__field_sortorder2=LIST(**{'elementclass': _gen_p_sanyo4930_68, 'length': _NUMPBSLOTS}) 
 527          return self.__field_sortorder2.getvalue() 
 528   
 529 -    def __setfield_sortorder2(self, value): 
 530          if isinstance(value,LIST): 
 531              self.__field_sortorder2=value 
 532          else: 
 533              self.__field_sortorder2=LIST(value,**{'elementclass': _gen_p_sanyo4930_68, 'length': _NUMPBSLOTS}) 
 534   
 535 -    def __delfield_sortorder2(self): del self.__field_sortorder2 
 536   
 537      sortorder2=property(__getfield_sortorder2, __setfield_sortorder2, __delfield_sortorder2, "Is this the same") 
 538   
 539 -    def __getfield_speeddialindex(self): 
 540          try: self.__field_speeddialindex 
 541          except: 
 542              self.__field_speeddialindex=LIST(**{'elementclass': _gen_p_sanyo4930_70, 'length': _NUMSPEEDDIALS}) 
 543          return self.__field_speeddialindex.getvalue() 
 544   
 545 -    def __setfield_speeddialindex(self, value): 
 546          if isinstance(value,LIST): 
 547              self.__field_speeddialindex=value 
 548          else: 
 549              self.__field_speeddialindex=LIST(value,**{'elementclass': _gen_p_sanyo4930_70, 'length': _NUMSPEEDDIALS}) 
 550   
 551 -    def __delfield_speeddialindex(self): del self.__field_speeddialindex 
 552   
 553      speeddialindex=property(__getfield_speeddialindex, __setfield_speeddialindex, __delfield_speeddialindex, None) 
 554   
 555 -    def __getfield_longnumbersindex(self): 
 556          try: self.__field_longnumbersindex 
 557          except: 
 558              self.__field_longnumbersindex=LIST(**{'elementclass': _gen_p_sanyo4930_72, 'length': _NUMLONGNUMBERS}) 
 559          return self.__field_longnumbersindex.getvalue() 
 560   
 561 -    def __setfield_longnumbersindex(self, value): 
 562          if isinstance(value,LIST): 
 563              self.__field_longnumbersindex=value 
 564          else: 
 565              self.__field_longnumbersindex=LIST(value,**{'elementclass': _gen_p_sanyo4930_72, 'length': _NUMLONGNUMBERS}) 
 566   
 567 -    def __delfield_longnumbersindex(self): del self.__field_longnumbersindex 
 568   
 569      longnumbersindex=property(__getfield_longnumbersindex, __setfield_longnumbersindex, __delfield_longnumbersindex, None) 
 570   
 571 -    def __getfield_emails(self): 
 572          try: self.__field_emails 
 573          except: 
 574              self.__field_emails=LIST(**{'elementclass': _gen_p_sanyo4930_74, 'length': _NUMPBSLOTS}) 
 575          return self.__field_emails.getvalue() 
 576   
 577 -    def __setfield_emails(self, value): 
 578          if isinstance(value,LIST): 
 579              self.__field_emails=value 
 580          else: 
 581              self.__field_emails=LIST(value,**{'elementclass': _gen_p_sanyo4930_74, 'length': _NUMPBSLOTS}) 
 582   
 583 -    def __delfield_emails(self): del self.__field_emails 
 584   
 585      emails=property(__getfield_emails, __setfield_emails, __delfield_emails, "Sorted list of slots with Email") 
 586   
 587 -    def __getfield_emailfirstletters(self): 
 588          return self.__field_emailfirstletters.getvalue() 
 589   
 590 -    def __setfield_emailfirstletters(self, value): 
 591          if isinstance(value,USTRING): 
 592              self.__field_emailfirstletters=value 
 593          else: 
 594              self.__field_emailfirstletters=USTRING(value,**{'terminator': None, 'sizeinbytes': _NUMPBSLOTS}) 
 595   
 596 -    def __delfield_emailfirstletters(self): del self.__field_emailfirstletters 
 597   
 598      emailfirstletters=property(__getfield_emailfirstletters, __setfield_emailfirstletters, __delfield_emailfirstletters, "First letters in sort order") 
 599   
 600 -    def __getfield_urls(self): 
 601          try: self.__field_urls 
 602          except: 
 603              self.__field_urls=LIST(**{'elementclass': _gen_p_sanyo4930_77, 'length': _NUMPBSLOTS}) 
 604          return self.__field_urls.getvalue() 
 605   
 606 -    def __setfield_urls(self, value): 
 607          if isinstance(value,LIST): 
 608              self.__field_urls=value 
 609          else: 
 610              self.__field_urls=LIST(value,**{'elementclass': _gen_p_sanyo4930_77, 'length': _NUMPBSLOTS}) 
 611   
 612 -    def __delfield_urls(self): del self.__field_urls 
 613   
 614      urls=property(__getfield_urls, __setfield_urls, __delfield_urls, "Sorted list of slots with a URL") 
 615   
 616 -    def __getfield_urlfirstletters(self): 
 617          return self.__field_urlfirstletters.getvalue() 
 618   
 619 -    def __setfield_urlfirstletters(self, value): 
 620          if isinstance(value,USTRING): 
 621              self.__field_urlfirstletters=value 
 622          else: 
 623              self.__field_urlfirstletters=USTRING(value,**{'terminator': None, 'sizeinbytes': _NUMPBSLOTS}) 
 624   
 625 -    def __delfield_urlfirstletters(self): del self.__field_urlfirstletters 
 626   
 627      urlfirstletters=property(__getfield_urlfirstletters, __setfield_urlfirstletters, __delfield_urlfirstletters, "First letters in sort order") 
 628   
 629 -    def __getfield_pad(self): 
 630          try: self.__field_pad 
 631          except: 
 632              self.__field_pad=UNKNOWN() 
 633          return self.__field_pad.getvalue() 
 634   
 635 -    def __setfield_pad(self, value): 
 636          if isinstance(value,UNKNOWN): 
 637              self.__field_pad=value 
 638          else: 
 639              self.__field_pad=UNKNOWN(value,) 
 640   
 641 -    def __delfield_pad(self): del self.__field_pad 
 642   
 643      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
 644   
 645 -    def iscontainer(self): 
 646          return True 
 647   
 648 -    def containerelements(self): 
 649          yield ('startcommand', self.__field_startcommand, "Starting command for R/W buf parts") 
 650          yield ('bufsize', self.__field_bufsize, None) 
 651          yield ('comment', self.__field_comment, None) 
 652          yield ('usedflags', self.__field_usedflags, None) 
 653          yield ('slotsused', self.__field_slotsused, None) 
 654          yield ('slotsused2', self.__field_slotsused2, "Always seems to be the same.  Why duplicated?") 
 655          yield ('numemail', self.__field_numemail, "Num of slots with email") 
 656          yield ('numurl', self.__field_numurl, "Num of slots with URL") 
 657          yield ('firsttypes', self.__field_firsttypes, None) 
 658          yield ('sortorder', self.__field_sortorder, None) 
 659          yield ('pbfirstletters', self.__field_pbfirstletters, None) 
 660          yield ('sortorder2', self.__field_sortorder2, "Is this the same") 
 661          yield ('speeddialindex', self.__field_speeddialindex, None) 
 662          yield ('longnumbersindex', self.__field_longnumbersindex, None) 
 663          yield ('emails', self.__field_emails, "Sorted list of slots with Email") 
 664          yield ('emailfirstletters', self.__field_emailfirstletters, "First letters in sort order") 
 665          yield ('urls', self.__field_urls, "Sorted list of slots with a URL") 
 666          yield ('urlfirstletters', self.__field_urlfirstletters, "First letters in sort order") 
 667          yield ('pad', self.__field_pad, None) 
 668   
 669   
 670   
 671   
 672 -class _gen_p_sanyo4930_57(BaseProtogenClass): 
 673      'Anonymous inner class' 
 674      __fields=['used'] 
 675   
 676 -    def __init__(self, *args, **kwargs): 
 677          dict={} 
 678          # What was supplied to this function 
 679          dict.update(kwargs) 
 680          # Parent constructor 
 681          super(_gen_p_sanyo4930_57,self).__init__(**dict) 
 682          if self.__class__ is _gen_p_sanyo4930_57: 
 683              self._update(args,dict) 
 684   
 685   
 686 -    def getfields(self): 
 687          return self.__fields 
 688   
 689   
 690 -    def _update(self, args, kwargs): 
 691          super(_gen_p_sanyo4930_57,self)._update(args,kwargs) 
 692          keys=kwargs.keys() 
 693          for key in keys: 
 694              if key in self.__fields: 
 695                  setattr(self, key, kwargs[key]) 
 696                  del kwargs[key] 
 697          # Were any unrecognized kwargs passed in? 
 698          if __debug__: 
 699              self._complainaboutunusedargs(_gen_p_sanyo4930_57,kwargs) 
 700          if len(args): 
 701              dict2={'sizeinbytes': 1} 
 702              dict2.update(kwargs) 
 703              kwargs=dict2 
 704              self.__field_used=UINT(*args,**dict2) 
 705          # Make all P fields that haven't already been constructed 
 706   
 707   
 708 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 709          'Writes this packet to the supplied buffer' 
 710          self._bufferstartoffset=buf.getcurrentoffset() 
 711          self.__field_used.writetobuffer(buf) 
 712          self._bufferendoffset=buf.getcurrentoffset() 
 713          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 714   
 715   
 716 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 717          'Reads this packet from the supplied buffer' 
 718          self._bufferstartoffset=buf.getcurrentoffset() 
 719          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 720          self.__field_used=UINT(**{'sizeinbytes': 1}) 
 721          self.__field_used.readfrombuffer(buf) 
 722          self._bufferendoffset=buf.getcurrentoffset() 
 723   
 724   
 725 -    def __getfield_used(self): 
 726          return self.__field_used.getvalue() 
 727   
 728 -    def __setfield_used(self, value): 
 729          if isinstance(value,UINT): 
 730              self.__field_used=value 
 731          else: 
 732              self.__field_used=UINT(value,**{'sizeinbytes': 1}) 
 733   
 734 -    def __delfield_used(self): del self.__field_used 
 735   
 736      used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 
 737   
 738 -    def iscontainer(self): 
 739          return True 
 740   
 741 -    def containerelements(self): 
 742          yield ('used', self.__field_used, "1 if slot in use") 
 743   
 744   
 745   
 746   
 747 -class _gen_p_sanyo4930_63(BaseProtogenClass): 
 748      'Anonymous inner class' 
 749      __fields=['firsttype'] 
 750   
 751 -    def __init__(self, *args, **kwargs): 
 752          dict={} 
 753          # What was supplied to this function 
 754          dict.update(kwargs) 
 755          # Parent constructor 
 756          super(_gen_p_sanyo4930_63,self).__init__(**dict) 
 757          if self.__class__ is _gen_p_sanyo4930_63: 
 758              self._update(args,dict) 
 759   
 760   
 761 -    def getfields(self): 
 762          return self.__fields 
 763   
 764   
 765 -    def _update(self, args, kwargs): 
 766          super(_gen_p_sanyo4930_63,self)._update(args,kwargs) 
 767          keys=kwargs.keys() 
 768          for key in keys: 
 769              if key in self.__fields: 
 770                  setattr(self, key, kwargs[key]) 
 771                  del kwargs[key] 
 772          # Were any unrecognized kwargs passed in? 
 773          if __debug__: 
 774              self._complainaboutunusedargs(_gen_p_sanyo4930_63,kwargs) 
 775          if len(args): 
 776              dict2={'sizeinbytes': 1} 
 777              dict2.update(kwargs) 
 778              kwargs=dict2 
 779              self.__field_firsttype=UINT(*args,**dict2) 
 780          # Make all P fields that haven't already been constructed 
 781   
 782   
 783 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 784          'Writes this packet to the supplied buffer' 
 785          self._bufferstartoffset=buf.getcurrentoffset() 
 786          self.__field_firsttype.writetobuffer(buf) 
 787          self._bufferendoffset=buf.getcurrentoffset() 
 788          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 789   
 790   
 791 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 792          'Reads this packet from the supplied buffer' 
 793          self._bufferstartoffset=buf.getcurrentoffset() 
 794          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 795          self.__field_firsttype=UINT(**{'sizeinbytes': 1}) 
 796          self.__field_firsttype.readfrombuffer(buf) 
 797          self._bufferendoffset=buf.getcurrentoffset() 
 798   
 799   
 800 -    def __getfield_firsttype(self): 
 801          return self.__field_firsttype.getvalue() 
 802   
 803 -    def __setfield_firsttype(self, value): 
 804          if isinstance(value,UINT): 
 805              self.__field_firsttype=value 
 806          else: 
 807              self.__field_firsttype=UINT(value,**{'sizeinbytes': 1}) 
 808   
 809 -    def __delfield_firsttype(self): del self.__field_firsttype 
 810   
 811      firsttype=property(__getfield_firsttype, __setfield_firsttype, __delfield_firsttype, "First phone number type in each slot") 
 812   
 813 -    def iscontainer(self): 
 814          return True 
 815   
 816 -    def containerelements(self): 
 817          yield ('firsttype', self.__field_firsttype, "First phone number type in each slot") 
 818   
 819   
 820   
 821   
 822 -class _gen_p_sanyo4930_65(BaseProtogenClass): 
 823      'Anonymous inner class' 
 824      __fields=['pbslot'] 
 825   
 826 -    def __init__(self, *args, **kwargs): 
 827          dict={} 
 828          # What was supplied to this function 
 829          dict.update(kwargs) 
 830          # Parent constructor 
 831          super(_gen_p_sanyo4930_65,self).__init__(**dict) 
 832          if self.__class__ is _gen_p_sanyo4930_65: 
 833              self._update(args,dict) 
 834   
 835   
 836 -    def getfields(self): 
 837          return self.__fields 
 838   
 839   
 840 -    def _update(self, args, kwargs): 
 841          super(_gen_p_sanyo4930_65,self)._update(args,kwargs) 
 842          keys=kwargs.keys() 
 843          for key in keys: 
 844              if key in self.__fields: 
 845                  setattr(self, key, kwargs[key]) 
 846                  del kwargs[key] 
 847          # Were any unrecognized kwargs passed in? 
 848          if __debug__: 
 849              self._complainaboutunusedargs(_gen_p_sanyo4930_65,kwargs) 
 850          if len(args): 
 851              dict2={'sizeinbytes': 2, 'default': 0xffff} 
 852              dict2.update(kwargs) 
 853              kwargs=dict2 
 854              self.__field_pbslot=UINT(*args,**dict2) 
 855          # Make all P fields that haven't already been constructed 
 856   
 857   
 858 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 859          'Writes this packet to the supplied buffer' 
 860          self._bufferstartoffset=buf.getcurrentoffset() 
 861          self.__field_pbslot.writetobuffer(buf) 
 862          self._bufferendoffset=buf.getcurrentoffset() 
 863          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 864   
 865   
 866 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 867          'Reads this packet from the supplied buffer' 
 868          self._bufferstartoffset=buf.getcurrentoffset() 
 869          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 870          self.__field_pbslot=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
 871          self.__field_pbslot.readfrombuffer(buf) 
 872          self._bufferendoffset=buf.getcurrentoffset() 
 873   
 874   
 875 -    def __getfield_pbslot(self): 
 876          return self.__field_pbslot.getvalue() 
 877   
 878 -    def __setfield_pbslot(self, value): 
 879          if isinstance(value,UINT): 
 880              self.__field_pbslot=value 
 881          else: 
 882              self.__field_pbslot=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff}) 
 883   
 884 -    def __delfield_pbslot(self): del self.__field_pbslot 
 885   
 886      pbslot=property(__getfield_pbslot, __setfield_pbslot, __delfield_pbslot, None) 
 887   
 888 -    def iscontainer(self): 
 889          return True 
 890   
 891 -    def containerelements(self): 
 892          yield ('pbslot', self.__field_pbslot, None) 
 893   
 894   
 895   
 896   
 897 -class _gen_p_sanyo4930_68(BaseProtogenClass): 
 898      'Anonymous inner class' 
 899      __fields=['pbslot'] 
 900   
 901 -    def __init__(self, *args, **kwargs): 
 902          dict={} 
 903          # What was supplied to this function 
 904          dict.update(kwargs) 
 905          # Parent constructor 
 906          super(_gen_p_sanyo4930_68,self).__init__(**dict) 
 907          if self.__class__ is _gen_p_sanyo4930_68: 
 908              self._update(args,dict) 
 909   
 910   
 911 -    def getfields(self): 
 912          return self.__fields 
 913   
 914   
 915 -    def _update(self, args, kwargs): 
 916          super(_gen_p_sanyo4930_68,self)._update(args,kwargs) 
 917          keys=kwargs.keys() 
 918          for key in keys: 
 919              if key in self.__fields: 
 920                  setattr(self, key, kwargs[key]) 
 921                  del kwargs[key] 
 922          # Were any unrecognized kwargs passed in? 
 923          if __debug__: 
 924              self._complainaboutunusedargs(_gen_p_sanyo4930_68,kwargs) 
 925          if len(args): 
 926              dict2={'sizeinbytes': 2, 'default': 0xffff} 
 927              dict2.update(kwargs) 
 928              kwargs=dict2 
 929              self.__field_pbslot=UINT(*args,**dict2) 
 930          # Make all P fields that haven't already been constructed 
 931   
 932   
 933 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 934          'Writes this packet to the supplied buffer' 
 935          self._bufferstartoffset=buf.getcurrentoffset() 
 936          self.__field_pbslot.writetobuffer(buf) 
 937          self._bufferendoffset=buf.getcurrentoffset() 
 938          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 939   
 940   
 941 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 942          'Reads this packet from the supplied buffer' 
 943          self._bufferstartoffset=buf.getcurrentoffset() 
 944          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 945          self.__field_pbslot=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
 946          self.__field_pbslot.readfrombuffer(buf) 
 947          self._bufferendoffset=buf.getcurrentoffset() 
 948   
 949   
 950 -    def __getfield_pbslot(self): 
 951          return self.__field_pbslot.getvalue() 
 952   
 953 -    def __setfield_pbslot(self, value): 
 954          if isinstance(value,UINT): 
 955              self.__field_pbslot=value 
 956          else: 
 957              self.__field_pbslot=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff}) 
 958   
 959 -    def __delfield_pbslot(self): del self.__field_pbslot 
 960   
 961      pbslot=property(__getfield_pbslot, __setfield_pbslot, __delfield_pbslot, None) 
 962   
 963 -    def iscontainer(self): 
 964          return True 
 965   
 966 -    def containerelements(self): 
 967          yield ('pbslot', self.__field_pbslot, None) 
 968   
 969   
 970   
 971   
 972 -class _gen_p_sanyo4930_70(BaseProtogenClass): 
 973      'Anonymous inner class' 
 974      __fields=['pbslotandtype'] 
 975   
 976 -    def __init__(self, *args, **kwargs): 
 977          dict={} 
 978          # What was supplied to this function 
 979          dict.update(kwargs) 
 980          # Parent constructor 
 981          super(_gen_p_sanyo4930_70,self).__init__(**dict) 
 982          if self.__class__ is _gen_p_sanyo4930_70: 
 983              self._update(args,dict) 
 984   
 985   
 986 -    def getfields(self): 
 987          return self.__fields 
 988   
 989   
 990 -    def _update(self, args, kwargs): 
 991          super(_gen_p_sanyo4930_70,self)._update(args,kwargs) 
 992          keys=kwargs.keys() 
 993          for key in keys: 
 994              if key in self.__fields: 
 995                  setattr(self, key, kwargs[key]) 
 996                  del kwargs[key] 
 997          # Were any unrecognized kwargs passed in? 
 998          if __debug__: 
 999              self._complainaboutunusedargs(_gen_p_sanyo4930_70,kwargs) 
1000          if len(args): 
1001              dict2={'sizeinbytes': 2, 'default': 0xffff} 
1002              dict2.update(kwargs) 
1003              kwargs=dict2 
1004              self.__field_pbslotandtype=UINT(*args,**dict2) 
1005          # Make all P fields that haven't already been constructed 
1006   
1007   
1008 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1009          'Writes this packet to the supplied buffer' 
1010          self._bufferstartoffset=buf.getcurrentoffset() 
1011          self.__field_pbslotandtype.writetobuffer(buf) 
1012          self._bufferendoffset=buf.getcurrentoffset() 
1013          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1014   
1015   
1016 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1017          'Reads this packet from the supplied buffer' 
1018          self._bufferstartoffset=buf.getcurrentoffset() 
1019          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1020          self.__field_pbslotandtype=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
1021          self.__field_pbslotandtype.readfrombuffer(buf) 
1022          self._bufferendoffset=buf.getcurrentoffset() 
1023   
1024   
1025 -    def __getfield_pbslotandtype(self): 
1026          return self.__field_pbslotandtype.getvalue() 
1027   
1028 -    def __setfield_pbslotandtype(self, value): 
1029          if isinstance(value,UINT): 
1030              self.__field_pbslotandtype=value 
1031          else: 
1032              self.__field_pbslotandtype=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff}) 
1033   
1034 -    def __delfield_pbslotandtype(self): del self.__field_pbslotandtype 
1035   
1036      pbslotandtype=property(__getfield_pbslotandtype, __setfield_pbslotandtype, __delfield_pbslotandtype, None) 
1037   
1038 -    def iscontainer(self): 
1039          return True 
1040   
1041 -    def containerelements(self): 
1042          yield ('pbslotandtype', self.__field_pbslotandtype, None) 
1043   
1044   
1045   
1046   
1047 -class _gen_p_sanyo4930_72(BaseProtogenClass): 
1048      'Anonymous inner class' 
1049      __fields=['pbslotandtype'] 
1050   
1051 -    def __init__(self, *args, **kwargs): 
1052          dict={} 
1053          # What was supplied to this function 
1054          dict.update(kwargs) 
1055          # Parent constructor 
1056          super(_gen_p_sanyo4930_72,self).__init__(**dict) 
1057          if self.__class__ is _gen_p_sanyo4930_72: 
1058              self._update(args,dict) 
1059   
1060   
1061 -    def getfields(self): 
1062          return self.__fields 
1063   
1064   
1065 -    def _update(self, args, kwargs): 
1066          super(_gen_p_sanyo4930_72,self)._update(args,kwargs) 
1067          keys=kwargs.keys() 
1068          for key in keys: 
1069              if key in self.__fields: 
1070                  setattr(self, key, kwargs[key]) 
1071                  del kwargs[key] 
1072          # Were any unrecognized kwargs passed in? 
1073          if __debug__: 
1074              self._complainaboutunusedargs(_gen_p_sanyo4930_72,kwargs) 
1075          if len(args): 
1076              dict2={'sizeinbytes': 2, 'default': 0xffff} 
1077              dict2.update(kwargs) 
1078              kwargs=dict2 
1079              self.__field_pbslotandtype=UINT(*args,**dict2) 
1080          # Make all P fields that haven't already been constructed 
1081   
1082   
1083 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1084          'Writes this packet to the supplied buffer' 
1085          self._bufferstartoffset=buf.getcurrentoffset() 
1086          self.__field_pbslotandtype.writetobuffer(buf) 
1087          self._bufferendoffset=buf.getcurrentoffset() 
1088          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1089   
1090   
1091 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1092          'Reads this packet from the supplied buffer' 
1093          self._bufferstartoffset=buf.getcurrentoffset() 
1094          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1095          self.__field_pbslotandtype=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
1096          self.__field_pbslotandtype.readfrombuffer(buf) 
1097          self._bufferendoffset=buf.getcurrentoffset() 
1098   
1099   
1100 -    def __getfield_pbslotandtype(self): 
1101          return self.__field_pbslotandtype.getvalue() 
1102   
1103 -    def __setfield_pbslotandtype(self, value): 
1104          if isinstance(value,UINT): 
1105              self.__field_pbslotandtype=value 
1106          else: 
1107              self.__field_pbslotandtype=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff}) 
1108   
1109 -    def __delfield_pbslotandtype(self): del self.__field_pbslotandtype 
1110   
1111      pbslotandtype=property(__getfield_pbslotandtype, __setfield_pbslotandtype, __delfield_pbslotandtype, None) 
1112   
1113 -    def iscontainer(self): 
1114          return True 
1115   
1116 -    def containerelements(self): 
1117          yield ('pbslotandtype', self.__field_pbslotandtype, None) 
1118   
1119   
1120   
1121   
1122 -class _gen_p_sanyo4930_74(BaseProtogenClass): 
1123      'Anonymous inner class' 
1124      __fields=['pbslot'] 
1125   
1126 -    def __init__(self, *args, **kwargs): 
1127          dict={} 
1128          # What was supplied to this function 
1129          dict.update(kwargs) 
1130          # Parent constructor 
1131          super(_gen_p_sanyo4930_74,self).__init__(**dict) 
1132          if self.__class__ is _gen_p_sanyo4930_74: 
1133              self._update(args,dict) 
1134   
1135   
1136 -    def getfields(self): 
1137          return self.__fields 
1138   
1139   
1140 -    def _update(self, args, kwargs): 
1141          super(_gen_p_sanyo4930_74,self)._update(args,kwargs) 
1142          keys=kwargs.keys() 
1143          for key in keys: 
1144              if key in self.__fields: 
1145                  setattr(self, key, kwargs[key]) 
1146                  del kwargs[key] 
1147          # Were any unrecognized kwargs passed in? 
1148          if __debug__: 
1149              self._complainaboutunusedargs(_gen_p_sanyo4930_74,kwargs) 
1150          if len(args): 
1151              dict2={'sizeinbytes': 2, 'default': 0xffff} 
1152              dict2.update(kwargs) 
1153              kwargs=dict2 
1154              self.__field_pbslot=UINT(*args,**dict2) 
1155          # Make all P fields that haven't already been constructed 
1156   
1157   
1158 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1159          'Writes this packet to the supplied buffer' 
1160          self._bufferstartoffset=buf.getcurrentoffset() 
1161          self.__field_pbslot.writetobuffer(buf) 
1162          self._bufferendoffset=buf.getcurrentoffset() 
1163          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1164   
1165   
1166 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1167          'Reads this packet from the supplied buffer' 
1168          self._bufferstartoffset=buf.getcurrentoffset() 
1169          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1170          self.__field_pbslot=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
1171          self.__field_pbslot.readfrombuffer(buf) 
1172          self._bufferendoffset=buf.getcurrentoffset() 
1173   
1174   
1175 -    def __getfield_pbslot(self): 
1176          return self.__field_pbslot.getvalue() 
1177   
1178 -    def __setfield_pbslot(self, value): 
1179          if isinstance(value,UINT): 
1180              self.__field_pbslot=value 
1181          else: 
1182              self.__field_pbslot=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff}) 
1183   
1184 -    def __delfield_pbslot(self): del self.__field_pbslot 
1185   
1186      pbslot=property(__getfield_pbslot, __setfield_pbslot, __delfield_pbslot, None) 
1187   
1188 -    def iscontainer(self): 
1189          return True 
1190   
1191 -    def containerelements(self): 
1192          yield ('pbslot', self.__field_pbslot, None) 
1193   
1194   
1195   
1196   
1197 -class _gen_p_sanyo4930_77(BaseProtogenClass): 
1198      'Anonymous inner class' 
1199      __fields=['pbslot'] 
1200   
1201 -    def __init__(self, *args, **kwargs): 
1202          dict={} 
1203          # What was supplied to this function 
1204          dict.update(kwargs) 
1205          # Parent constructor 
1206          super(_gen_p_sanyo4930_77,self).__init__(**dict) 
1207          if self.__class__ is _gen_p_sanyo4930_77: 
1208              self._update(args,dict) 
1209   
1210   
1211 -    def getfields(self): 
1212          return self.__fields 
1213   
1214   
1215 -    def _update(self, args, kwargs): 
1216          super(_gen_p_sanyo4930_77,self)._update(args,kwargs) 
1217          keys=kwargs.keys() 
1218          for key in keys: 
1219              if key in self.__fields: 
1220                  setattr(self, key, kwargs[key]) 
1221                  del kwargs[key] 
1222          # Were any unrecognized kwargs passed in? 
1223          if __debug__: 
1224              self._complainaboutunusedargs(_gen_p_sanyo4930_77,kwargs) 
1225          if len(args): 
1226              dict2={'sizeinbytes': 2, 'default': 0xffff} 
1227              dict2.update(kwargs) 
1228              kwargs=dict2 
1229              self.__field_pbslot=UINT(*args,**dict2) 
1230          # Make all P fields that haven't already been constructed 
1231   
1232   
1233 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1234          'Writes this packet to the supplied buffer' 
1235          self._bufferstartoffset=buf.getcurrentoffset() 
1236          self.__field_pbslot.writetobuffer(buf) 
1237          self._bufferendoffset=buf.getcurrentoffset() 
1238          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1239   
1240   
1241 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1242          'Reads this packet from the supplied buffer' 
1243          self._bufferstartoffset=buf.getcurrentoffset() 
1244          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1245          self.__field_pbslot=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 
1246          self.__field_pbslot.readfrombuffer(buf) 
1247          self._bufferendoffset=buf.getcurrentoffset() 
1248   
1249   
1250 -    def __getfield_pbslot(self): 
1251          return self.__field_pbslot.getvalue() 
1252   
1253 -    def __setfield_pbslot(self, value): 
1254          if isinstance(value,UINT): 
1255              self.__field_pbslot=value 
1256          else: 
1257              self.__field_pbslot=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff}) 
1258   
1259 -    def __delfield_pbslot(self): del self.__field_pbslot 
1260   
1261      pbslot=property(__getfield_pbslot, __setfield_pbslot, __delfield_pbslot, None) 
1262   
1263 -    def iscontainer(self): 
1264          return True 
1265   
1266 -    def containerelements(self): 
1267          yield ('pbslot', self.__field_pbslot, None) 
1268   
1269   
1270   
1271   
1272 -class calleridbuffer(BaseProtogenClass): 
1273      "Index so that phone can show a name instead of number" 
1274      __fields=['maxentries', 'startcommand', 'bufsize', 'comment', 'numentries', 'items', 'pad'] 
1275   
1276 -    def __init__(self, *args, **kwargs): 
1277          dict={} 
1278          # What was supplied to this function 
1279          dict.update(kwargs) 
1280          # Parent constructor 
1281          super(calleridbuffer,self).__init__(**dict) 
1282          if self.__class__ is calleridbuffer: 
1283              self._update(args,dict) 
1284   
1285   
1286 -    def getfields(self): 
1287          return self.__fields 
1288   
1289   
1290 -    def _update(self, args, kwargs): 
1291          super(calleridbuffer,self)._update(args,kwargs) 
1292          keys=kwargs.keys() 
1293          for key in keys: 
1294              if key in self.__fields: 
1295                  setattr(self, key, kwargs[key]) 
1296                  del kwargs[key] 
1297          # Were any unrecognized kwargs passed in? 
1298          if __debug__: 
1299              self._complainaboutunusedargs(calleridbuffer,kwargs) 
1300          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1301          # Make all P fields that haven't already been constructed 
1302          try: self.__field_maxentries 
1303          except: 
1304              self.__field_maxentries=UINT(**{'constant': 700}) 
1305          try: self.__field_startcommand 
1306          except: 
1307              self.__field_startcommand=UINT(**{'constant': 0x46}) 
1308          try: self.__field_bufsize 
1309          except: 
1310              self.__field_bufsize=UINT(**{'constant': 9216}) 
1311          try: self.__field_comment 
1312          except: 
1313              self.__field_comment=USTRING(**{'default': "callerid"}) 
1314   
1315   
1316 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1317          'Writes this packet to the supplied buffer' 
1318          self._bufferstartoffset=buf.getcurrentoffset() 
1319          self.__field_numentries.writetobuffer(buf) 
1320          try: self.__field_items 
1321          except: 
1322              self.__field_items=LIST(**{'length': self.maxentries, 'elementclass': calleridentry, 'createdefault': True}) 
1323          self.__field_items.writetobuffer(buf) 
1324          try: self.__field_pad 
1325          except: 
1326              self.__field_pad=UNKNOWN() 
1327          self.__field_pad.writetobuffer(buf) 
1328          self._bufferendoffset=buf.getcurrentoffset() 
1329          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1330   
1331   
1332 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1333          'Reads this packet from the supplied buffer' 
1334          self._bufferstartoffset=buf.getcurrentoffset() 
1335          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1336          self.__field_numentries=UINT(**{'sizeinbytes': 2}) 
1337          self.__field_numentries.readfrombuffer(buf) 
1338          self.__field_items=LIST(**{'length': self.maxentries, 'elementclass': calleridentry, 'createdefault': True}) 
1339          self.__field_items.readfrombuffer(buf) 
1340          self.__field_pad=UNKNOWN() 
1341          self.__field_pad.readfrombuffer(buf) 
1342          self._bufferendoffset=buf.getcurrentoffset() 
1343   
1344   
1345 -    def __getfield_maxentries(self): 
1346          return self.__field_maxentries.getvalue() 
1347   
1348 -    def __setfield_maxentries(self, value): 
1349          if isinstance(value,UINT): 
1350              self.__field_maxentries=value 
1351          else: 
1352              self.__field_maxentries=UINT(value,**{'constant': 700}) 
1353   
1354 -    def __delfield_maxentries(self): del self.__field_maxentries 
1355   
1356      maxentries=property(__getfield_maxentries, __setfield_maxentries, __delfield_maxentries, None) 
1357   
1358 -    def __getfield_startcommand(self): 
1359          return self.__field_startcommand.getvalue() 
1360   
1361 -    def __setfield_startcommand(self, value): 
1362          if isinstance(value,UINT): 
1363              self.__field_startcommand=value 
1364          else: 
1365              self.__field_startcommand=UINT(value,**{'constant': 0x46}) 
1366   
1367 -    def __delfield_startcommand(self): del self.__field_startcommand 
1368   
1369      startcommand=property(__getfield_startcommand, __setfield_startcommand, __delfield_startcommand, "Starting command for R/W buf parts") 
1370   
1371 -    def __getfield_bufsize(self): 
1372          return self.__field_bufsize.getvalue() 
1373   
1374 -    def __setfield_bufsize(self, value): 
1375          if isinstance(value,UINT): 
1376              self.__field_bufsize=value 
1377          else: 
1378              self.__field_bufsize=UINT(value,**{'constant': 9216}) 
1379   
1380 -    def __delfield_bufsize(self): del self.__field_bufsize 
1381   
1382      bufsize=property(__getfield_bufsize, __setfield_bufsize, __delfield_bufsize, None) 
1383   
1384 -    def __getfield_comment(self): 
1385          try: self.__field_comment 
1386          except: 
1387              self.__field_comment=USTRING(**{'default': "callerid"}) 
1388          return self.__field_comment.getvalue() 
1389   
1390 -    def __setfield_comment(self, value): 
1391          if isinstance(value,USTRING): 
1392              self.__field_comment=value 
1393          else: 
1394              self.__field_comment=USTRING(value,**{'default': "callerid"}) 
1395   
1396 -    def __delfield_comment(self): del self.__field_comment 
1397   
1398      comment=property(__getfield_comment, __setfield_comment, __delfield_comment, None) 
1399   
1400 -    def __getfield_numentries(self): 
1401          return self.__field_numentries.getvalue() 
1402   
1403 -    def __setfield_numentries(self, value): 
1404          if isinstance(value,UINT): 
1405              self.__field_numentries=value 
1406          else: 
1407              self.__field_numentries=UINT(value,**{'sizeinbytes': 2}) 
1408   
1409 -    def __delfield_numentries(self): del self.__field_numentries 
1410   
1411      numentries=property(__getfield_numentries, __setfield_numentries, __delfield_numentries, "Number phone numbers") 
1412   
1413 -    def __getfield_items(self): 
1414          try: self.__field_items 
1415          except: 
1416              self.__field_items=LIST(**{'length': self.maxentries, 'elementclass': calleridentry, 'createdefault': True}) 
1417          return self.__field_items.getvalue() 
1418   
1419 -    def __setfield_items(self, value): 
1420          if isinstance(value,LIST): 
1421              self.__field_items=value 
1422          else: 
1423              self.__field_items=LIST(value,**{'length': self.maxentries, 'elementclass': calleridentry, 'createdefault': True}) 
1424   
1425 -    def __delfield_items(self): del self.__field_items 
1426   
1427      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
1428   
1429 -    def __getfield_pad(self): 
1430          try: self.__field_pad 
1431          except: 
1432              self.__field_pad=UNKNOWN() 
1433          return self.__field_pad.getvalue() 
1434   
1435 -    def __setfield_pad(self, value): 
1436          if isinstance(value,UNKNOWN): 
1437              self.__field_pad=value 
1438          else: 
1439              self.__field_pad=UNKNOWN(value,) 
1440   
1441 -    def __delfield_pad(self): del self.__field_pad 
1442   
1443      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
1444   
1445 -    def iscontainer(self): 
1446          return True 
1447   
1448 -    def containerelements(self): 
1449          yield ('maxentries', self.__field_maxentries, None) 
1450          yield ('startcommand', self.__field_startcommand, "Starting command for R/W buf parts") 
1451          yield ('bufsize', self.__field_bufsize, None) 
1452          yield ('comment', self.__field_comment, None) 
1453          yield ('numentries', self.__field_numentries, "Number phone numbers") 
1454          yield ('items', self.__field_items, None) 
1455          yield ('pad', self.__field_pad, None) 
1456   
1457   
1458   
1459   
1460 -class evententry(BaseProtogenClass): 
1461      __fields=['slot', 'eventname', 'pad1', 'eventname_len', 'start', 'end', 'location', 'pad2', 'location_len', 'alarmdiff', 'period', 'dom', 'alarm', 'pad3', 'serial', 'pad4', 'ringtone'] 
1462   
1463 -    def __init__(self, *args, **kwargs): 
1464          dict={} 
1465          # What was supplied to this function 
1466          dict.update(kwargs) 
1467          # Parent constructor 
1468          super(evententry,self).__init__(**dict) 
1469          if self.__class__ is evententry: 
1470              self._update(args,dict) 
1471   
1472   
1473 -    def getfields(self): 
1474          return self.__fields 
1475   
1476   
1477 -    def _update(self, args, kwargs): 
1478          super(evententry,self)._update(args,kwargs) 
1479          keys=kwargs.keys() 
1480          for key in keys: 
1481              if key in self.__fields: 
1482                  setattr(self, key, kwargs[key]) 
1483                  del kwargs[key] 
1484          # Were any unrecognized kwargs passed in? 
1485          if __debug__: 
1486              self._complainaboutunusedargs(evententry,kwargs) 
1487          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1488          # Make all P fields that haven't already been constructed 
1489   
1490   
1491 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1492          'Writes this packet to the supplied buffer' 
1493          self._bufferstartoffset=buf.getcurrentoffset() 
1494          self.__field_slot.writetobuffer(buf) 
1495          self.__field_eventname.writetobuffer(buf) 
1496          try: self.__field_pad1 
1497          except: 
1498              self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7}) 
1499          self.__field_pad1.writetobuffer(buf) 
1500          self.__field_eventname_len.writetobuffer(buf) 
1501          self.__field_start.writetobuffer(buf) 
1502          self.__field_end.writetobuffer(buf) 
1503          self.__field_location.writetobuffer(buf) 
1504          try: self.__field_pad2 
1505          except: 
1506              self.__field_pad2=UNKNOWN(**{'sizeinbytes': 7}) 
1507          self.__field_pad2.writetobuffer(buf) 
1508          self.__field_location_len.writetobuffer(buf) 
1509          self.__field_alarmdiff.writetobuffer(buf) 
1510          self.__field_period.writetobuffer(buf) 
1511          self.__field_dom.writetobuffer(buf) 
1512          self.__field_alarm.writetobuffer(buf) 
1513          try: self.__field_pad3 
1514          except: 
1515              self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1}) 
1516          self.__field_pad3.writetobuffer(buf) 
1517          try: self.__field_serial 
1518          except: 
1519              self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 
1520          self.__field_serial.writetobuffer(buf) 
1521          try: self.__field_pad4 
1522          except: 
1523              self.__field_pad4=UNKNOWN(**{'sizeinbytes': 3}) 
1524          self.__field_pad4.writetobuffer(buf) 
1525          self.__field_ringtone.writetobuffer(buf) 
1526          self._bufferendoffset=buf.getcurrentoffset() 
1527          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1528   
1529   
1530 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1531          'Reads this packet from the supplied buffer' 
1532          self._bufferstartoffset=buf.getcurrentoffset() 
1533          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1534          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
1535          self.__field_slot.readfrombuffer(buf) 
1536          self.__field_eventname=USTRING(**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
1537          self.__field_eventname.readfrombuffer(buf) 
1538          self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7}) 
1539          self.__field_pad1.readfrombuffer(buf) 
1540          self.__field_eventname_len=UINT(**{'sizeinbytes': 1}) 
1541          self.__field_eventname_len.readfrombuffer(buf) 
1542          self.__field_start=UINT(**{'sizeinbytes': 4}) 
1543          self.__field_start.readfrombuffer(buf) 
1544          self.__field_end=UINT(**{'sizeinbytes': 4}) 
1545          self.__field_end.readfrombuffer(buf) 
1546          self.__field_location=USTRING(**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
1547          self.__field_location.readfrombuffer(buf) 
1548          self.__field_pad2=UNKNOWN(**{'sizeinbytes': 7}) 
1549          self.__field_pad2.readfrombuffer(buf) 
1550          self.__field_location_len=UINT(**{'sizeinbytes': 1}) 
1551          self.__field_location_len.readfrombuffer(buf) 
1552          self.__field_alarmdiff=UINT(**{'sizeinbytes': 4}) 
1553          self.__field_alarmdiff.readfrombuffer(buf) 
1554          self.__field_period=UINT(**{'sizeinbytes': 1}) 
1555          self.__field_period.readfrombuffer(buf) 
1556          self.__field_dom=UINT(**{'sizeinbytes': 1}) 
1557          self.__field_dom.readfrombuffer(buf) 
1558          self.__field_alarm=UINT(**{'sizeinbytes': 4}) 
1559          self.__field_alarm.readfrombuffer(buf) 
1560          self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1}) 
1561          self.__field_pad3.readfrombuffer(buf) 
1562          self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 
1563          self.__field_serial.readfrombuffer(buf) 
1564          self.__field_pad4=UNKNOWN(**{'sizeinbytes': 3}) 
1565          self.__field_pad4.readfrombuffer(buf) 
1566          self.__field_ringtone=UINT(**{'sizeinbytes': 2}) 
1567          self.__field_ringtone.readfrombuffer(buf) 
1568          self._bufferendoffset=buf.getcurrentoffset() 
1569   
1570   
1571 -    def __getfield_slot(self): 
1572          return self.__field_slot.getvalue() 
1573   
1574 -    def __setfield_slot(self, value): 
1575          if isinstance(value,UINT): 
1576              self.__field_slot=value 
1577          else: 
1578              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
1579   
1580 -    def __delfield_slot(self): del self.__field_slot 
1581   
1582      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
1583   
1584 -    def __getfield_eventname(self): 
1585          return self.__field_eventname.getvalue() 
1586   
1587 -    def __setfield_eventname(self, value): 
1588          if isinstance(value,USTRING): 
1589              self.__field_eventname=value 
1590          else: 
1591              self.__field_eventname=USTRING(value,**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
1592   
1593 -    def __delfield_eventname(self): del self.__field_eventname 
1594   
1595      eventname=property(__getfield_eventname, __setfield_eventname, __delfield_eventname, None) 
1596   
1597 -    def __getfield_pad1(self): 
1598          try: self.__field_pad1 
1599          except: 
1600              self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7}) 
1601          return self.__field_pad1.getvalue() 
1602   
1603 -    def __setfield_pad1(self, value): 
1604          if isinstance(value,UNKNOWN): 
1605              self.__field_pad1=value 
1606          else: 
1607              self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 7}) 
1608   
1609 -    def __delfield_pad1(self): del self.__field_pad1 
1610   
1611      pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None) 
1612   
1613 -    def __getfield_eventname_len(self): 
1614          return self.__field_eventname_len.getvalue() 
1615   
1616 -    def __setfield_eventname_len(self, value): 
1617          if isinstance(value,UINT): 
1618              self.__field_eventname_len=value 
1619          else: 
1620              self.__field_eventname_len=UINT(value,**{'sizeinbytes': 1}) 
1621   
1622 -    def __delfield_eventname_len(self): del self.__field_eventname_len 
1623   
1624      eventname_len=property(__getfield_eventname_len, __setfield_eventname_len, __delfield_eventname_len, None) 
1625   
1626 -    def __getfield_start(self): 
1627          return self.__field_start.getvalue() 
1628   
1629 -    def __setfield_start(self, value): 
1630          if isinstance(value,UINT): 
1631              self.__field_start=value 
1632          else: 
1633              self.__field_start=UINT(value,**{'sizeinbytes': 4}) 
1634   
1635 -    def __delfield_start(self): del self.__field_start 
1636   
1637      start=property(__getfield_start, __setfield_start, __delfield_start, "# seconds since Jan 1, 1980 approximately") 
1638   
1639 -    def __getfield_end(self): 
1640          return self.__field_end.getvalue() 
1641   
1642 -    def __setfield_end(self, value): 
1643          if isinstance(value,UINT): 
1644              self.__field_end=value 
1645          else: 
1646              self.__field_end=UINT(value,**{'sizeinbytes': 4}) 
1647   
1648 -    def __delfield_end(self): del self.__field_end 
1649   
1650      end=property(__getfield_end, __setfield_end, __delfield_end, None) 
1651   
1652 -    def __getfield_location(self): 
1653          return self.__field_location.getvalue() 
1654   
1655 -    def __setfield_location(self, value): 
1656          if isinstance(value,USTRING): 
1657              self.__field_location=value 
1658          else: 
1659              self.__field_location=USTRING(value,**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
1660   
1661 -    def __delfield_location(self): del self.__field_location 
1662   
1663      location=property(__getfield_location, __setfield_location, __delfield_location, None) 
1664   
1665 -    def __getfield_pad2(self): 
1666          try: self.__field_pad2 
1667          except: 
1668              self.__field_pad2=UNKNOWN(**{'sizeinbytes': 7}) 
1669          return self.__field_pad2.getvalue() 
1670   
1671 -    def __setfield_pad2(self, value): 
1672          if isinstance(value,UNKNOWN): 
1673              self.__field_pad2=value 
1674          else: 
1675              self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 7}) 
1676   
1677 -    def __delfield_pad2(self): del self.__field_pad2 
1678   
1679      pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None) 
1680   
1681 -    def __getfield_location_len(self): 
1682          return self.__field_location_len.getvalue() 
1683   
1684 -    def __setfield_location_len(self, value): 
1685          if isinstance(value,UINT): 
1686              self.__field_location_len=value 
1687          else: 
1688              self.__field_location_len=UINT(value,**{'sizeinbytes': 1}) 
1689   
1690 -    def __delfield_location_len(self): del self.__field_location_len 
1691   
1692      location_len=property(__getfield_location_len, __setfield_location_len, __delfield_location_len, None) 
1693   
1694 -    def __getfield_alarmdiff(self): 
1695          return self.__field_alarmdiff.getvalue() 
1696   
1697 -    def __setfield_alarmdiff(self, value): 
1698          if isinstance(value,UINT): 
1699              self.__field_alarmdiff=value 
1700          else: 
1701              self.__field_alarmdiff=UINT(value,**{'sizeinbytes': 4}) 
1702   
1703 -    def __delfield_alarmdiff(self): del self.__field_alarmdiff 
1704   
1705      alarmdiff=property(__getfield_alarmdiff, __setfield_alarmdiff, __delfield_alarmdiff, "Displayed alarm time") 
1706   
1707 -    def __getfield_period(self): 
1708          return self.__field_period.getvalue() 
1709   
1710 -    def __setfield_period(self, value): 
1711          if isinstance(value,UINT): 
1712              self.__field_period=value 
1713          else: 
1714              self.__field_period=UINT(value,**{'sizeinbytes': 1}) 
1715   
1716 -    def __delfield_period(self): del self.__field_period 
1717   
1718      period=property(__getfield_period, __setfield_period, __delfield_period, "No, Daily, Weekly, Monthly, Yearly") 
1719   
1720 -    def __getfield_dom(self): 
1721          return self.__field_dom.getvalue() 
1722   
1723 -    def __setfield_dom(self, value): 
1724          if isinstance(value,UINT): 
1725              self.__field_dom=value 
1726          else: 
1727              self.__field_dom=UINT(value,**{'sizeinbytes': 1}) 
1728   
1729 -    def __delfield_dom(self): del self.__field_dom 
1730   
1731      dom=property(__getfield_dom, __setfield_dom, __delfield_dom, "Day of month for the event") 
1732   
1733 -    def __getfield_alarm(self): 
1734          return self.__field_alarm.getvalue() 
1735   
1736 -    def __setfield_alarm(self, value): 
1737          if isinstance(value,UINT): 
1738              self.__field_alarm=value 
1739          else: 
1740              self.__field_alarm=UINT(value,**{'sizeinbytes': 4}) 
1741   
1742 -    def __delfield_alarm(self): del self.__field_alarm 
1743   
1744      alarm=property(__getfield_alarm, __setfield_alarm, __delfield_alarm, None) 
1745   
1746 -    def __getfield_pad3(self): 
1747          try: self.__field_pad3 
1748          except: 
1749              self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1}) 
1750          return self.__field_pad3.getvalue() 
1751   
1752 -    def __setfield_pad3(self, value): 
1753          if isinstance(value,UNKNOWN): 
1754              self.__field_pad3=value 
1755          else: 
1756              self.__field_pad3=UNKNOWN(value,**{'sizeinbytes': 1}) 
1757   
1758 -    def __delfield_pad3(self): del self.__field_pad3 
1759   
1760      pad3=property(__getfield_pad3, __setfield_pad3, __delfield_pad3, None) 
1761   
1762 -    def __getfield_serial(self): 
1763          try: self.__field_serial 
1764          except: 
1765              self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 
1766          return self.__field_serial.getvalue() 
1767   
1768 -    def __setfield_serial(self, value): 
1769          if isinstance(value,UINT): 
1770              self.__field_serial=value 
1771          else: 
1772              self.__field_serial=UINT(value,**{'sizeinbytes': 1, 'default': 0}) 
1773   
1774 -    def __delfield_serial(self): del self.__field_serial 
1775   
1776      serial=property(__getfield_serial, __setfield_serial, __delfield_serial, "Some kind of serial number") 
1777   
1778 -    def __getfield_pad4(self): 
1779          try: self.__field_pad4 
1780          except: 
1781              self.__field_pad4=UNKNOWN(**{'sizeinbytes': 3}) 
1782          return self.__field_pad4.getvalue() 
1783   
1784 -    def __setfield_pad4(self, value): 
1785          if isinstance(value,UNKNOWN): 
1786              self.__field_pad4=value 
1787          else: 
1788              self.__field_pad4=UNKNOWN(value,**{'sizeinbytes': 3}) 
1789   
1790 -    def __delfield_pad4(self): del self.__field_pad4 
1791   
1792      pad4=property(__getfield_pad4, __setfield_pad4, __delfield_pad4, None) 
1793   
1794 -    def __getfield_ringtone(self): 
1795          return self.__field_ringtone.getvalue() 
1796   
1797 -    def __setfield_ringtone(self, value): 
1798          if isinstance(value,UINT): 
1799              self.__field_ringtone=value 
1800          else: 
1801              self.__field_ringtone=UINT(value,**{'sizeinbytes': 2}) 
1802   
1803 -    def __delfield_ringtone(self): del self.__field_ringtone 
1804   
1805      ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 
1806   
1807 -    def iscontainer(self): 
1808          return True 
1809   
1810 -    def containerelements(self): 
1811          yield ('slot', self.__field_slot, None) 
1812          yield ('eventname', self.__field_eventname, None) 
1813          yield ('pad1', self.__field_pad1, None) 
1814          yield ('eventname_len', self.__field_eventname_len, None) 
1815          yield ('start', self.__field_start, "# seconds since Jan 1, 1980 approximately") 
1816          yield ('end', self.__field_end, None) 
1817          yield ('location', self.__field_location, None) 
1818          yield ('pad2', self.__field_pad2, None) 
1819          yield ('location_len', self.__field_location_len, None) 
1820          yield ('alarmdiff', self.__field_alarmdiff, "Displayed alarm time") 
1821          yield ('period', self.__field_period, "No, Daily, Weekly, Monthly, Yearly") 
1822          yield ('dom', self.__field_dom, "Day of month for the event") 
1823          yield ('alarm', self.__field_alarm, None) 
1824          yield ('pad3', self.__field_pad3, None) 
1825          yield ('serial', self.__field_serial, "Some kind of serial number") 
1826          yield ('pad4', self.__field_pad4, None) 
1827          yield ('ringtone', self.__field_ringtone, None) 
1828   
1829   
1830   
1831   
1832 -class eventrequest(BaseProtogenClass): 
1833      __fields=['header', 'slot', 'pad'] 
1834   
1835 -    def __init__(self, *args, **kwargs): 
1836          dict={} 
1837          # What was supplied to this function 
1838          dict.update(kwargs) 
1839          # Parent constructor 
1840          super(eventrequest,self).__init__(**dict) 
1841          if self.__class__ is eventrequest: 
1842              self._update(args,dict) 
1843   
1844   
1845 -    def getfields(self): 
1846          return self.__fields 
1847   
1848   
1849 -    def _update(self, args, kwargs): 
1850          super(eventrequest,self)._update(args,kwargs) 
1851          keys=kwargs.keys() 
1852          for key in keys: 
1853              if key in self.__fields: 
1854                  setattr(self, key, kwargs[key]) 
1855                  del kwargs[key] 
1856          # Were any unrecognized kwargs passed in? 
1857          if __debug__: 
1858              self._complainaboutunusedargs(eventrequest,kwargs) 
1859          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1860          # Make all P fields that haven't already been constructed 
1861   
1862   
1863 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1864          'Writes this packet to the supplied buffer' 
1865          self._bufferstartoffset=buf.getcurrentoffset() 
1866          try: self.__field_header 
1867          except: 
1868              self.__field_header=qcpheader(**{'packettype': 0x0c, 'command': 0x23}) 
1869          self.__field_header.writetobuffer(buf) 
1870          self.__field_slot.writetobuffer(buf) 
1871          try: self.__field_pad 
1872          except: 
1873              self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 
1874          self.__field_pad.writetobuffer(buf) 
1875          self._bufferendoffset=buf.getcurrentoffset() 
1876          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1877   
1878   
1879 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1880          'Reads this packet from the supplied buffer' 
1881          self._bufferstartoffset=buf.getcurrentoffset() 
1882          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1883          self.__field_header=qcpheader(**{'packettype': 0x0c, 'command': 0x23}) 
1884          self.__field_header.readfrombuffer(buf) 
1885          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
1886          self.__field_slot.readfrombuffer(buf) 
1887          self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 
1888          self.__field_pad.readfrombuffer(buf) 
1889          self._bufferendoffset=buf.getcurrentoffset() 
1890   
1891   
1892 -    def __getfield_header(self): 
1893          try: self.__field_header 
1894          except: 
1895              self.__field_header=qcpheader(**{'packettype': 0x0c, 'command': 0x23}) 
1896          return self.__field_header.getvalue() 
1897   
1898 -    def __setfield_header(self, value): 
1899          if isinstance(value,qcpheader): 
1900              self.__field_header=value 
1901          else: 
1902              self.__field_header=qcpheader(value,**{'packettype': 0x0c, 'command': 0x23}) 
1903   
1904 -    def __delfield_header(self): del self.__field_header 
1905   
1906      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
1907   
1908 -    def __getfield_slot(self): 
1909          return self.__field_slot.getvalue() 
1910   
1911 -    def __setfield_slot(self, value): 
1912          if isinstance(value,UINT): 
1913              self.__field_slot=value 
1914          else: 
1915              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
1916   
1917 -    def __delfield_slot(self): del self.__field_slot 
1918   
1919      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
1920   
1921 -    def __getfield_pad(self): 
1922          try: self.__field_pad 
1923          except: 
1924              self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 
1925          return self.__field_pad.getvalue() 
1926   
1927 -    def __setfield_pad(self, value): 
1928          if isinstance(value,UNKNOWN): 
1929              self.__field_pad=value 
1930          else: 
1931              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 129}) 
1932   
1933 -    def __delfield_pad(self): del self.__field_pad 
1934   
1935      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
1936   
1937 -    def iscontainer(self): 
1938          return True 
1939   
1940 -    def containerelements(self): 
1941          yield ('header', self.__field_header, None) 
1942          yield ('slot', self.__field_slot, None) 
1943          yield ('pad', self.__field_pad, None) 
1944   
1945   
1946   
1947   
1948 -class eventresponse(BaseProtogenClass): 
1949      __fields=['header', 'entry', 'pad'] 
1950   
1951 -    def __init__(self, *args, **kwargs): 
1952          dict={} 
1953          # What was supplied to this function 
1954          dict.update(kwargs) 
1955          # Parent constructor 
1956          super(eventresponse,self).__init__(**dict) 
1957          if self.__class__ is eventresponse: 
1958              self._update(args,dict) 
1959   
1960   
1961 -    def getfields(self): 
1962          return self.__fields 
1963   
1964   
1965 -    def _update(self, args, kwargs): 
1966          super(eventresponse,self)._update(args,kwargs) 
1967          keys=kwargs.keys() 
1968          for key in keys: 
1969              if key in self.__fields: 
1970                  setattr(self, key, kwargs[key]) 
1971                  del kwargs[key] 
1972          # Were any unrecognized kwargs passed in? 
1973          if __debug__: 
1974              self._complainaboutunusedargs(eventresponse,kwargs) 
1975          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1976          # Make all P fields that haven't already been constructed 
1977   
1978   
1979 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1980          'Writes this packet to the supplied buffer' 
1981          self._bufferstartoffset=buf.getcurrentoffset() 
1982          self.__field_header.writetobuffer(buf) 
1983          self.__field_entry.writetobuffer(buf) 
1984          self.__field_pad.writetobuffer(buf) 
1985          self._bufferendoffset=buf.getcurrentoffset() 
1986          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1987   
1988   
1989 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1990          'Reads this packet from the supplied buffer' 
1991          self._bufferstartoffset=buf.getcurrentoffset() 
1992          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1993          self.__field_header=qcpheader() 
1994          self.__field_header.readfrombuffer(buf) 
1995          self.__field_entry=evententry() 
1996          self.__field_entry.readfrombuffer(buf) 
1997          self.__field_pad=UNKNOWN() 
1998          self.__field_pad.readfrombuffer(buf) 
1999          self._bufferendoffset=buf.getcurrentoffset() 
2000   
2001   
2002 -    def __getfield_header(self): 
2003          return self.__field_header.getvalue() 
2004   
2005 -    def __setfield_header(self, value): 
2006          if isinstance(value,qcpheader): 
2007              self.__field_header=value 
2008          else: 
2009              self.__field_header=qcpheader(value,) 
2010   
2011 -    def __delfield_header(self): del self.__field_header 
2012   
2013      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
2014   
2015 -    def __getfield_entry(self): 
2016          return self.__field_entry.getvalue() 
2017   
2018 -    def __setfield_entry(self, value): 
2019          if isinstance(value,evententry): 
2020              self.__field_entry=value 
2021          else: 
2022              self.__field_entry=evententry(value,) 
2023   
2024 -    def __delfield_entry(self): del self.__field_entry 
2025   
2026      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
2027   
2028 -    def __getfield_pad(self): 
2029          return self.__field_pad.getvalue() 
2030   
2031 -    def __setfield_pad(self, value): 
2032          if isinstance(value,UNKNOWN): 
2033              self.__field_pad=value 
2034          else: 
2035              self.__field_pad=UNKNOWN(value,) 
2036   
2037 -    def __delfield_pad(self): del self.__field_pad 
2038   
2039      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
2040   
2041 -    def iscontainer(self): 
2042          return True 
2043   
2044 -    def containerelements(self): 
2045          yield ('header', self.__field_header, None) 
2046          yield ('entry', self.__field_entry, None) 
2047          yield ('pad', self.__field_pad, None) 
2048   
2049   
2050   
2051   
2052 -class eventslotinuserequest(BaseProtogenClass): 
2053      __fields=['header', 'slot', 'pad'] 
2054   
2055 -    def __init__(self, *args, **kwargs): 
2056          dict={} 
2057          # What was supplied to this function 
2058          dict.update(kwargs) 
2059          # Parent constructor 
2060          super(eventslotinuserequest,self).__init__(**dict) 
2061          if self.__class__ is eventslotinuserequest: 
2062              self._update(args,dict) 
2063   
2064   
2065 -    def getfields(self): 
2066          return self.__fields 
2067   
2068   
2069 -    def _update(self, args, kwargs): 
2070          super(eventslotinuserequest,self)._update(args,kwargs) 
2071          keys=kwargs.keys() 
2072          for key in keys: 
2073              if key in self.__fields: 
2074                  setattr(self, key, kwargs[key]) 
2075                  del kwargs[key] 
2076          # Were any unrecognized kwargs passed in? 
2077          if __debug__: 
2078              self._complainaboutunusedargs(eventslotinuserequest,kwargs) 
2079          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2080          # Make all P fields that haven't already been constructed 
2081   
2082   
2083 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2084          'Writes this packet to the supplied buffer' 
2085          self._bufferstartoffset=buf.getcurrentoffset() 
2086          try: self.__field_header 
2087          except: 
2088              self.__field_header=qcpheader(**{'readwrite': 0x26, 'packettype': 0x0d, 'command': 0x74}) 
2089          self.__field_header.writetobuffer(buf) 
2090          self.__field_slot.writetobuffer(buf) 
2091          try: self.__field_pad 
2092          except: 
2093              self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 
2094          self.__field_pad.writetobuffer(buf) 
2095          self._bufferendoffset=buf.getcurrentoffset() 
2096          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2097   
2098   
2099 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2100          'Reads this packet from the supplied buffer' 
2101          self._bufferstartoffset=buf.getcurrentoffset() 
2102          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2103          self.__field_header=qcpheader(**{'readwrite': 0x26, 'packettype': 0x0d, 'command': 0x74}) 
2104          self.__field_header.readfrombuffer(buf) 
2105          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
2106          self.__field_slot.readfrombuffer(buf) 
2107          self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 
2108          self.__field_pad.readfrombuffer(buf) 
2109          self._bufferendoffset=buf.getcurrentoffset() 
2110   
2111   
2112 -    def __getfield_header(self): 
2113          try: self.__field_header 
2114          except: 
2115              self.__field_header=qcpheader(**{'readwrite': 0x26, 'packettype': 0x0d, 'command': 0x74}) 
2116          return self.__field_header.getvalue() 
2117   
2118 -    def __setfield_header(self, value): 
2119          if isinstance(value,qcpheader): 
2120              self.__field_header=value 
2121          else: 
2122              self.__field_header=qcpheader(value,**{'readwrite': 0x26, 'packettype': 0x0d, 'command': 0x74}) 
2123   
2124 -    def __delfield_header(self): del self.__field_header 
2125   
2126      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
2127   
2128 -    def __getfield_slot(self): 
2129          return self.__field_slot.getvalue() 
2130   
2131 -    def __setfield_slot(self, value): 
2132          if isinstance(value,UINT): 
2133              self.__field_slot=value 
2134          else: 
2135              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
2136   
2137 -    def __delfield_slot(self): del self.__field_slot 
2138   
2139      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
2140   
2141 -    def __getfield_pad(self): 
2142          try: self.__field_pad 
2143          except: 
2144              self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 
2145          return self.__field_pad.getvalue() 
2146   
2147 -    def __setfield_pad(self, value): 
2148          if isinstance(value,UNKNOWN): 
2149              self.__field_pad=value 
2150          else: 
2151              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 129}) 
2152   
2153 -    def __delfield_pad(self): del self.__field_pad 
2154   
2155      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
2156   
2157 -    def iscontainer(self): 
2158          return True 
2159   
2160 -    def containerelements(self): 
2161          yield ('header', self.__field_header, None) 
2162          yield ('slot', self.__field_slot, None) 
2163          yield ('pad', self.__field_pad, None) 
2164   
2165   
2166   
2167   
2168 -class eventslotinuseresponse(BaseProtogenClass): 
2169      __fields=['header', 'slot', 'flag', 'pad'] 
2170   
2171 -    def __init__(self, *args, **kwargs): 
2172          dict={} 
2173          # What was supplied to this function 
2174          dict.update(kwargs) 
2175          # Parent constructor 
2176          super(eventslotinuseresponse,self).__init__(**dict) 
2177          if self.__class__ is eventslotinuseresponse: 
2178              self._update(args,dict) 
2179   
2180   
2181 -    def getfields(self): 
2182          return self.__fields 
2183   
2184   
2185 -    def _update(self, args, kwargs): 
2186          super(eventslotinuseresponse,self)._update(args,kwargs) 
2187          keys=kwargs.keys() 
2188          for key in keys: 
2189              if key in self.__fields: 
2190                  setattr(self, key, kwargs[key]) 
2191                  del kwargs[key] 
2192          # Were any unrecognized kwargs passed in? 
2193          if __debug__: 
2194              self._complainaboutunusedargs(eventslotinuseresponse,kwargs) 
2195          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2196          # Make all P fields that haven't already been constructed 
2197   
2198   
2199 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2200          'Writes this packet to the supplied buffer' 
2201          self._bufferstartoffset=buf.getcurrentoffset() 
2202          self.__field_header.writetobuffer(buf) 
2203          self.__field_slot.writetobuffer(buf) 
2204          self.__field_flag.writetobuffer(buf) 
2205          self.__field_pad.writetobuffer(buf) 
2206          self._bufferendoffset=buf.getcurrentoffset() 
2207          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2208   
2209   
2210 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2211          'Reads this packet from the supplied buffer' 
2212          self._bufferstartoffset=buf.getcurrentoffset() 
2213          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2214          self.__field_header=qcpheader() 
2215          self.__field_header.readfrombuffer(buf) 
2216          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
2217          self.__field_slot.readfrombuffer(buf) 
2218          self.__field_flag=UINT(**{'sizeinbytes': 1}) 
2219          self.__field_flag.readfrombuffer(buf) 
2220          self.__field_pad=UNKNOWN() 
2221          self.__field_pad.readfrombuffer(buf) 
2222          self._bufferendoffset=buf.getcurrentoffset() 
2223   
2224   
2225 -    def __getfield_header(self): 
2226          return self.__field_header.getvalue() 
2227   
2228 -    def __setfield_header(self, value): 
2229          if isinstance(value,qcpheader): 
2230              self.__field_header=value 
2231          else: 
2232              self.__field_header=qcpheader(value,) 
2233   
2234 -    def __delfield_header(self): del self.__field_header 
2235   
2236      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
2237   
2238 -    def __getfield_slot(self): 
2239          return self.__field_slot.getvalue() 
2240   
2241 -    def __setfield_slot(self, value): 
2242          if isinstance(value,UINT): 
2243              self.__field_slot=value 
2244          else: 
2245              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
2246   
2247 -    def __delfield_slot(self): del self.__field_slot 
2248   
2249      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
2250   
2251 -    def __getfield_flag(self): 
2252          return self.__field_flag.getvalue() 
2253   
2254 -    def __setfield_flag(self, value): 
2255          if isinstance(value,UINT): 
2256              self.__field_flag=value 
2257          else: 
2258              self.__field_flag=UINT(value,**{'sizeinbytes': 1}) 
2259   
2260 -    def __delfield_flag(self): del self.__field_flag 
2261   
2262      flag=property(__getfield_flag, __setfield_flag, __delfield_flag, None) 
2263   
2264 -    def __getfield_pad(self): 
2265          return self.__field_pad.getvalue() 
2266   
2267 -    def __setfield_pad(self, value): 
2268          if isinstance(value,UNKNOWN): 
2269              self.__field_pad=value 
2270          else: 
2271              self.__field_pad=UNKNOWN(value,) 
2272   
2273 -    def __delfield_pad(self): del self.__field_pad 
2274   
2275      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
2276   
2277 -    def iscontainer(self): 
2278          return True 
2279   
2280 -    def containerelements(self): 
2281          yield ('header', self.__field_header, None) 
2282          yield ('slot', self.__field_slot, None) 
2283          yield ('flag', self.__field_flag, None) 
2284          yield ('pad', self.__field_pad, None) 
2285   
2286   
2287   
2288   
2289 -class eventslotinuseupdaterequest(BaseProtogenClass): 
2290      __fields=['header', 'slot', 'flag', 'pad'] 
2291   
2292 -    def __init__(self, *args, **kwargs): 
2293          dict={} 
2294          # What was supplied to this function 
2295          dict.update(kwargs) 
2296          # Parent constructor 
2297          super(eventslotinuseupdaterequest,self).__init__(**dict) 
2298          if self.__class__ is eventslotinuseupdaterequest: 
2299              self._update(args,dict) 
2300   
2301   
2302 -    def getfields(self): 
2303          return self.__fields 
2304   
2305   
2306 -    def _update(self, args, kwargs): 
2307          super(eventslotinuseupdaterequest,self)._update(args,kwargs) 
2308          keys=kwargs.keys() 
2309          for key in keys: 
2310              if key in self.__fields: 
2311                  setattr(self, key, kwargs[key]) 
2312                  del kwargs[key] 
2313          # Were any unrecognized kwargs passed in? 
2314          if __debug__: 
2315              self._complainaboutunusedargs(eventslotinuseupdaterequest,kwargs) 
2316          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2317          # Make all P fields that haven't already been constructed 
2318   
2319   
2320 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2321          'Writes this packet to the supplied buffer' 
2322          self._bufferstartoffset=buf.getcurrentoffset() 
2323          try: self.__field_header 
2324          except: 
2325              self.__field_header=qcpwriteheader(**{'packettype': 0x0d, 'command': 0x74}) 
2326          self.__field_header.writetobuffer(buf) 
2327          self.__field_slot.writetobuffer(buf) 
2328          self.__field_flag.writetobuffer(buf) 
2329          try: self.__field_pad 
2330          except: 
2331              self.__field_pad=UNKNOWN(**{'sizeinbytes': 124}) 
2332          self.__field_pad.writetobuffer(buf) 
2333          self._bufferendoffset=buf.getcurrentoffset() 
2334          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2335   
2336   
2337 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2338          'Reads this packet from the supplied buffer' 
2339          self._bufferstartoffset=buf.getcurrentoffset() 
2340          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2341          self.__field_header=qcpwriteheader(**{'packettype': 0x0d, 'command': 0x74}) 
2342          self.__field_header.readfrombuffer(buf) 
2343          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
2344          self.__field_slot.readfrombuffer(buf) 
2345          self.__field_flag=UINT(**{'sizeinbytes': 1}) 
2346          self.__field_flag.readfrombuffer(buf) 
2347          self.__field_pad=UNKNOWN(**{'sizeinbytes': 124}) 
2348          self.__field_pad.readfrombuffer(buf) 
2349          self._bufferendoffset=buf.getcurrentoffset() 
2350   
2351   
2352 -    def __getfield_header(self): 
2353          try: self.__field_header 
2354          except: 
2355              self.__field_header=qcpwriteheader(**{'packettype': 0x0d, 'command': 0x74}) 
2356          return self.__field_header.getvalue() 
2357   
2358 -    def __setfield_header(self, value): 
2359          if isinstance(value,qcpwriteheader): 
2360              self.__field_header=value 
2361          else: 
2362              self.__field_header=qcpwriteheader(value,**{'packettype': 0x0d, 'command': 0x74}) 
2363   
2364 -    def __delfield_header(self): del self.__field_header 
2365   
2366      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
2367   
2368 -    def __getfield_slot(self): 
2369          return self.__field_slot.getvalue() 
2370   
2371 -    def __setfield_slot(self, value): 
2372          if isinstance(value,UINT): 
2373              self.__field_slot=value 
2374          else: 
2375              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
2376   
2377 -    def __delfield_slot(self): del self.__field_slot 
2378   
2379      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
2380   
2381 -    def __getfield_flag(self): 
2382          return self.__field_flag.getvalue() 
2383   
2384 -    def __setfield_flag(self, value): 
2385          if isinstance(value,UINT): 
2386              self.__field_flag=value 
2387          else: 
2388              self.__field_flag=UINT(value,**{'sizeinbytes': 1}) 
2389   
2390 -    def __delfield_flag(self): del self.__field_flag 
2391   
2392      flag=property(__getfield_flag, __setfield_flag, __delfield_flag, None) 
2393   
2394 -    def __getfield_pad(self): 
2395          try: self.__field_pad 
2396          except: 
2397              self.__field_pad=UNKNOWN(**{'sizeinbytes': 124}) 
2398          return self.__field_pad.getvalue() 
2399   
2400 -    def __setfield_pad(self, value): 
2401          if isinstance(value,UNKNOWN): 
2402              self.__field_pad=value 
2403          else: 
2404              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 124}) 
2405   
2406 -    def __delfield_pad(self): del self.__field_pad 
2407   
2408      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
2409   
2410 -    def iscontainer(self): 
2411          return True 
2412   
2413 -    def containerelements(self): 
2414          yield ('header', self.__field_header, None) 
2415          yield ('slot', self.__field_slot, None) 
2416          yield ('flag', self.__field_flag, None) 
2417          yield ('pad', self.__field_pad, None) 
2418   
2419   
2420   
2421   
2422 -class eventupdaterequest(BaseProtogenClass): 
2423      __fields=['header', 'entry', 'pad'] 
2424   
2425 -    def __init__(self, *args, **kwargs): 
2426          dict={} 
2427          # What was supplied to this function 
2428          dict.update(kwargs) 
2429          # Parent constructor 
2430          super(eventupdaterequest,self).__init__(**dict) 
2431          if self.__class__ is eventupdaterequest: 
2432              self._update(args,dict) 
2433   
2434   
2435 -    def getfields(self): 
2436          return self.__fields 
2437   
2438   
2439 -    def _update(self, args, kwargs): 
2440          super(eventupdaterequest,self)._update(args,kwargs) 
2441          keys=kwargs.keys() 
2442          for key in keys: 
2443              if key in self.__fields: 
2444                  setattr(self, key, kwargs[key]) 
2445                  del kwargs[key] 
2446          # Were any unrecognized kwargs passed in? 
2447          if __debug__: 
2448              self._complainaboutunusedargs(eventupdaterequest,kwargs) 
2449          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2450          # Make all P fields that haven't already been constructed 
2451   
2452   
2453 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2454          'Writes this packet to the supplied buffer' 
2455          self._bufferstartoffset=buf.getcurrentoffset() 
2456          try: self.__field_header 
2457          except: 
2458              self.__field_header=qcpwriteheader(**{'packettype': 0x0c, 'command':0x23}) 
2459          self.__field_header.writetobuffer(buf) 
2460          self.__field_entry.writetobuffer(buf) 
2461          try: self.__field_pad 
2462          except: 
2463              self.__field_pad=UNKNOWN(**{'sizeinbytes': 56}) 
2464          self.__field_pad.writetobuffer(buf) 
2465          self._bufferendoffset=buf.getcurrentoffset() 
2466          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2467   
2468   
2469 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2470          'Reads this packet from the supplied buffer' 
2471          self._bufferstartoffset=buf.getcurrentoffset() 
2472          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2473          self.__field_header=qcpwriteheader(**{'packettype': 0x0c, 'command':0x23}) 
2474          self.__field_header.readfrombuffer(buf) 
2475          self.__field_entry=evententry() 
2476          self.__field_entry.readfrombuffer(buf) 
2477          self.__field_pad=UNKNOWN(**{'sizeinbytes': 56}) 
2478          self.__field_pad.readfrombuffer(buf) 
2479          self._bufferendoffset=buf.getcurrentoffset() 
2480   
2481   
2482 -    def __getfield_header(self): 
2483          try: self.__field_header 
2484          except: 
2485              self.__field_header=qcpwriteheader(**{'packettype': 0x0c, 'command':0x23}) 
2486          return self.__field_header.getvalue() 
2487   
2488 -    def __setfield_header(self, value): 
2489          if isinstance(value,qcpwriteheader): 
2490              self.__field_header=value 
2491          else: 
2492              self.__field_header=qcpwriteheader(value,**{'packettype': 0x0c, 'command':0x23}) 
2493   
2494 -    def __delfield_header(self): del self.__field_header 
2495   
2496      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
2497   
2498 -    def __getfield_entry(self): 
2499          return self.__field_entry.getvalue() 
2500   
2501 -    def __setfield_entry(self, value): 
2502          if isinstance(value,evententry): 
2503              self.__field_entry=value 
2504          else: 
2505              self.__field_entry=evententry(value,) 
2506   
2507 -    def __delfield_entry(self): del self.__field_entry 
2508   
2509      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
2510   
2511 -    def __getfield_pad(self): 
2512          try: self.__field_pad 
2513          except: 
2514              self.__field_pad=UNKNOWN(**{'sizeinbytes': 56}) 
2515          return self.__field_pad.getvalue() 
2516   
2517 -    def __setfield_pad(self, value): 
2518          if isinstance(value,UNKNOWN): 
2519              self.__field_pad=value 
2520          else: 
2521              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 56}) 
2522   
2523 -    def __delfield_pad(self): del self.__field_pad 
2524   
2525      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
2526   
2527 -    def iscontainer(self): 
2528          return True 
2529   
2530 -    def containerelements(self): 
2531          yield ('header', self.__field_header, None) 
2532          yield ('entry', self.__field_entry, None) 
2533          yield ('pad', self.__field_pad, None) 
2534   
2535   
2536   
2537   
2538 -class callalarmrequest(BaseProtogenClass): 
2539      __fields=['header', 'slot', 'pad'] 
2540   
2541 -    def __init__(self, *args, **kwargs): 
2542          dict={} 
2543          # What was supplied to this function 
2544          dict.update(kwargs) 
2545          # Parent constructor 
2546          super(callalarmrequest,self).__init__(**dict) 
2547          if self.__class__ is callalarmrequest: 
2548              self._update(args,dict) 
2549   
2550   
2551 -    def getfields(self): 
2552          return self.__fields 
2553   
2554   
2555 -    def _update(self, args, kwargs): 
2556          super(callalarmrequest,self)._update(args,kwargs) 
2557          keys=kwargs.keys() 
2558          for key in keys: 
2559              if key in self.__fields: 
2560                  setattr(self, key, kwargs[key]) 
2561                  del kwargs[key] 
2562          # Were any unrecognized kwargs passed in? 
2563          if __debug__: 
2564              self._complainaboutunusedargs(callalarmrequest,kwargs) 
2565          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2566          # Make all P fields that haven't already been constructed 
2567   
2568   
2569 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2570          'Writes this packet to the supplied buffer' 
2571          self._bufferstartoffset=buf.getcurrentoffset() 
2572          try: self.__field_header 
2573          except: 
2574              self.__field_header=qcpheader(**{'packettype': 0x0c, 'command': 0x24}) 
2575          self.__field_header.writetobuffer(buf) 
2576          self.__field_slot.writetobuffer(buf) 
2577          try: self.__field_pad 
2578          except: 
2579              self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 
2580          self.__field_pad.writetobuffer(buf) 
2581          self._bufferendoffset=buf.getcurrentoffset() 
2582          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2583   
2584   
2585 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2586          'Reads this packet from the supplied buffer' 
2587          self._bufferstartoffset=buf.getcurrentoffset() 
2588          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2589          self.__field_header=qcpheader(**{'packettype': 0x0c, 'command': 0x24}) 
2590          self.__field_header.readfrombuffer(buf) 
2591          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
2592          self.__field_slot.readfrombuffer(buf) 
2593          self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 
2594          self.__field_pad.readfrombuffer(buf) 
2595          self._bufferendoffset=buf.getcurrentoffset() 
2596   
2597   
2598 -    def __getfield_header(self): 
2599          try: self.__field_header 
2600          except: 
2601              self.__field_header=qcpheader(**{'packettype': 0x0c, 'command': 0x24}) 
2602          return self.__field_header.getvalue() 
2603   
2604 -    def __setfield_header(self, value): 
2605          if isinstance(value,qcpheader): 
2606              self.__field_header=value 
2607          else: 
2608              self.__field_header=qcpheader(value,**{'packettype': 0x0c, 'command': 0x24}) 
2609   
2610 -    def __delfield_header(self): del self.__field_header 
2611   
2612      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
2613   
2614 -    def __getfield_slot(self): 
2615          return self.__field_slot.getvalue() 
2616   
2617 -    def __setfield_slot(self, value): 
2618          if isinstance(value,UINT): 
2619              self.__field_slot=value 
2620          else: 
2621              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
2622   
2623 -    def __delfield_slot(self): del self.__field_slot 
2624   
2625      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
2626   
2627 -    def __getfield_pad(self): 
2628          try: self.__field_pad 
2629          except: 
2630              self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 
2631          return self.__field_pad.getvalue() 
2632   
2633 -    def __setfield_pad(self, value): 
2634          if isinstance(value,UNKNOWN): 
2635              self.__field_pad=value 
2636          else: 
2637              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 129}) 
2638   
2639 -    def __delfield_pad(self): del self.__field_pad 
2640   
2641      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
2642   
2643 -    def iscontainer(self): 
2644          return True 
2645   
2646 -    def containerelements(self): 
2647          yield ('header', self.__field_header, None) 
2648          yield ('slot', self.__field_slot, None) 
2649          yield ('pad', self.__field_pad, None) 
2650   
2651   
2652   
2653   
2654 -class callalarmresponse(BaseProtogenClass): 
2655      __fields=['header', 'entry', 'pad'] 
2656   
2657 -    def __init__(self, *args, **kwargs): 
2658          dict={} 
2659          # What was supplied to this function 
2660          dict.update(kwargs) 
2661          # Parent constructor 
2662          super(callalarmresponse,self).__init__(**dict) 
2663          if self.__class__ is callalarmresponse: 
2664              self._update(args,dict) 
2665   
2666   
2667 -    def getfields(self): 
2668          return self.__fields 
2669   
2670   
2671 -    def _update(self, args, kwargs): 
2672          super(callalarmresponse,self)._update(args,kwargs) 
2673          keys=kwargs.keys() 
2674          for key in keys: 
2675              if key in self.__fields: 
2676                  setattr(self, key, kwargs[key]) 
2677                  del kwargs[key] 
2678          # Were any unrecognized kwargs passed in? 
2679          if __debug__: 
2680              self._complainaboutunusedargs(callalarmresponse,kwargs) 
2681          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2682          # Make all P fields that haven't already been constructed 
2683   
2684   
2685 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2686          'Writes this packet to the supplied buffer' 
2687          self._bufferstartoffset=buf.getcurrentoffset() 
2688          self.__field_header.writetobuffer(buf) 
2689          self.__field_entry.writetobuffer(buf) 
2690          self.__field_pad.writetobuffer(buf) 
2691          self._bufferendoffset=buf.getcurrentoffset() 
2692          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2693   
2694   
2695 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2696          'Reads this packet from the supplied buffer' 
2697          self._bufferstartoffset=buf.getcurrentoffset() 
2698          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2699          self.__field_header=qcpheader() 
2700          self.__field_header.readfrombuffer(buf) 
2701          self.__field_entry=callalarmentry() 
2702          self.__field_entry.readfrombuffer(buf) 
2703          self.__field_pad=UNKNOWN() 
2704          self.__field_pad.readfrombuffer(buf) 
2705          self._bufferendoffset=buf.getcurrentoffset() 
2706   
2707   
2708 -    def __getfield_header(self): 
2709          return self.__field_header.getvalue() 
2710   
2711 -    def __setfield_header(self, value): 
2712          if isinstance(value,qcpheader): 
2713              self.__field_header=value 
2714          else: 
2715              self.__field_header=qcpheader(value,) 
2716   
2717 -    def __delfield_header(self): del self.__field_header 
2718   
2719      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
2720   
2721 -    def __getfield_entry(self): 
2722          return self.__field_entry.getvalue() 
2723   
2724 -    def __setfield_entry(self, value): 
2725          if isinstance(value,callalarmentry): 
2726              self.__field_entry=value 
2727          else: 
2728              self.__field_entry=callalarmentry(value,) 
2729   
2730 -    def __delfield_entry(self): del self.__field_entry 
2731   
2732      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
2733   
2734 -    def __getfield_pad(self): 
2735          return self.__field_pad.getvalue() 
2736   
2737 -    def __setfield_pad(self, value): 
2738          if isinstance(value,UNKNOWN): 
2739              self.__field_pad=value 
2740          else: 
2741              self.__field_pad=UNKNOWN(value,) 
2742   
2743 -    def __delfield_pad(self): del self.__field_pad 
2744   
2745      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
2746   
2747 -    def iscontainer(self): 
2748          return True 
2749   
2750 -    def containerelements(self): 
2751          yield ('header', self.__field_header, None) 
2752          yield ('entry', self.__field_entry, None) 
2753          yield ('pad', self.__field_pad, None) 
2754   
2755   
2756   
2757   
2758 -class callalarmupdaterequest(BaseProtogenClass): 
2759      __fields=['header', 'entry', 'pad'] 
2760   
2761 -    def __init__(self, *args, **kwargs): 
2762          dict={} 
2763          # What was supplied to this function 
2764          dict.update(kwargs) 
2765          # Parent constructor 
2766          super(callalarmupdaterequest,self).__init__(**dict) 
2767          if self.__class__ is callalarmupdaterequest: 
2768              self._update(args,dict) 
2769   
2770   
2771 -    def getfields(self): 
2772          return self.__fields 
2773   
2774   
2775 -    def _update(self, args, kwargs): 
2776          super(callalarmupdaterequest,self)._update(args,kwargs) 
2777          keys=kwargs.keys() 
2778          for key in keys: 
2779              if key in self.__fields: 
2780                  setattr(self, key, kwargs[key]) 
2781                  del kwargs[key] 
2782          # Were any unrecognized kwargs passed in? 
2783          if __debug__: 
2784              self._complainaboutunusedargs(callalarmupdaterequest,kwargs) 
2785          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2786          # Make all P fields that haven't already been constructed 
2787   
2788   
2789 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2790          'Writes this packet to the supplied buffer' 
2791          self._bufferstartoffset=buf.getcurrentoffset() 
2792          try: self.__field_header 
2793          except: 
2794              self.__field_header=qcpwriteheader(**{'packettype': 0x0c, 'command':0x24}) 
2795          self.__field_header.writetobuffer(buf) 
2796          self.__field_entry.writetobuffer(buf) 
2797          try: self.__field_pad 
2798          except: 
2799              self.__field_pad=UNKNOWN(**{'sizeinbytes': 40}) 
2800          self.__field_pad.writetobuffer(buf) 
2801          self._bufferendoffset=buf.getcurrentoffset() 
2802          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2803   
2804   
2805 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2806          'Reads this packet from the supplied buffer' 
2807          self._bufferstartoffset=buf.getcurrentoffset() 
2808          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2809          self.__field_header=qcpwriteheader(**{'packettype': 0x0c, 'command':0x24}) 
2810          self.__field_header.readfrombuffer(buf) 
2811          self.__field_entry=callalarmentry() 
2812          self.__field_entry.readfrombuffer(buf) 
2813          self.__field_pad=UNKNOWN(**{'sizeinbytes': 40}) 
2814          self.__field_pad.readfrombuffer(buf) 
2815          self._bufferendoffset=buf.getcurrentoffset() 
2816   
2817   
2818 -    def __getfield_header(self): 
2819          try: self.__field_header 
2820          except: 
2821              self.__field_header=qcpwriteheader(**{'packettype': 0x0c, 'command':0x24}) 
2822          return self.__field_header.getvalue() 
2823   
2824 -    def __setfield_header(self, value): 
2825          if isinstance(value,qcpwriteheader): 
2826              self.__field_header=value 
2827          else: 
2828              self.__field_header=qcpwriteheader(value,**{'packettype': 0x0c, 'command':0x24}) 
2829   
2830 -    def __delfield_header(self): del self.__field_header 
2831   
2832      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
2833   
2834 -    def __getfield_entry(self): 
2835          return self.__field_entry.getvalue() 
2836   
2837 -    def __setfield_entry(self, value): 
2838          if isinstance(value,callalarmentry): 
2839              self.__field_entry=value 
2840          else: 
2841              self.__field_entry=callalarmentry(value,) 
2842   
2843 -    def __delfield_entry(self): del self.__field_entry 
2844   
2845      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
2846   
2847 -    def __getfield_pad(self): 
2848          try: self.__field_pad 
2849          except: 
2850              self.__field_pad=UNKNOWN(**{'sizeinbytes': 40}) 
2851          return self.__field_pad.getvalue() 
2852   
2853 -    def __setfield_pad(self, value): 
2854          if isinstance(value,UNKNOWN): 
2855              self.__field_pad=value 
2856          else: 
2857              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 40}) 
2858   
2859 -    def __delfield_pad(self): del self.__field_pad 
2860   
2861      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
2862   
2863 -    def iscontainer(self): 
2864          return True 
2865   
2866 -    def containerelements(self): 
2867          yield ('header', self.__field_header, None) 
2868          yield ('entry', self.__field_entry, None) 
2869          yield ('pad', self.__field_pad, None) 
2870   
2871   
2872   
2873   
2874 -class callalarmslotinuserequest(BaseProtogenClass): 
2875      __fields=['header', 'slot', 'pad'] 
2876   
2877 -    def __init__(self, *args, **kwargs): 
2878          dict={} 
2879          # What was supplied to this function 
2880          dict.update(kwargs) 
2881          # Parent constructor 
2882          super(callalarmslotinuserequest,self).__init__(**dict) 
2883          if self.__class__ is callalarmslotinuserequest: 
2884              self._update(args,dict) 
2885   
2886   
2887 -    def getfields(self): 
2888          return self.__fields 
2889   
2890   
2891 -    def _update(self, args, kwargs): 
2892          super(callalarmslotinuserequest,self)._update(args,kwargs) 
2893          keys=kwargs.keys() 
2894          for key in keys: 
2895              if key in self.__fields: 
2896                  setattr(self, key, kwargs[key]) 
2897                  del kwargs[key] 
2898          # Were any unrecognized kwargs passed in? 
2899          if __debug__: 
2900              self._complainaboutunusedargs(callalarmslotinuserequest,kwargs) 
2901          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2902          # Make all P fields that haven't already been constructed 
2903   
2904   
2905 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2906          'Writes this packet to the supplied buffer' 
2907          self._bufferstartoffset=buf.getcurrentoffset() 
2908          try: self.__field_header 
2909          except: 
2910              self.__field_header=qcpheader(**{'packettype': 0x0d, 'command': 0x76}) 
2911          self.__field_header.writetobuffer(buf) 
2912          self.__field_slot.writetobuffer(buf) 
2913          try: self.__field_pad 
2914          except: 
2915              self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 
2916          self.__field_pad.writetobuffer(buf) 
2917          self._bufferendoffset=buf.getcurrentoffset() 
2918          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2919   
2920   
2921 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2922          'Reads this packet from the supplied buffer' 
2923          self._bufferstartoffset=buf.getcurrentoffset() 
2924          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2925          self.__field_header=qcpheader(**{'packettype': 0x0d, 'command': 0x76}) 
2926          self.__field_header.readfrombuffer(buf) 
2927          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
2928          self.__field_slot.readfrombuffer(buf) 
2929          self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 
2930          self.__field_pad.readfrombuffer(buf) 
2931          self._bufferendoffset=buf.getcurrentoffset() 
2932   
2933   
2934 -    def __getfield_header(self): 
2935          try: self.__field_header 
2936          except: 
2937              self.__field_header=qcpheader(**{'packettype': 0x0d, 'command': 0x76}) 
2938          return self.__field_header.getvalue() 
2939   
2940 -    def __setfield_header(self, value): 
2941          if isinstance(value,qcpheader): 
2942              self.__field_header=value 
2943          else: 
2944              self.__field_header=qcpheader(value,**{'packettype': 0x0d, 'command': 0x76}) 
2945   
2946 -    def __delfield_header(self): del self.__field_header 
2947   
2948      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
2949   
2950 -    def __getfield_slot(self): 
2951          return self.__field_slot.getvalue() 
2952   
2953 -    def __setfield_slot(self, value): 
2954          if isinstance(value,UINT): 
2955              self.__field_slot=value 
2956          else: 
2957              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
2958   
2959 -    def __delfield_slot(self): del self.__field_slot 
2960   
2961      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
2962   
2963 -    def __getfield_pad(self): 
2964          try: self.__field_pad 
2965          except: 
2966              self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 
2967          return self.__field_pad.getvalue() 
2968   
2969 -    def __setfield_pad(self, value): 
2970          if isinstance(value,UNKNOWN): 
2971              self.__field_pad=value 
2972          else: 
2973              self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 129}) 
2974   
2975 -    def __delfield_pad(self): del self.__field_pad 
2976   
2977      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
2978   
2979 -    def iscontainer(self): 
2980          return True 
2981   
2982 -    def containerelements(self): 
2983          yield ('header', self.__field_header, None) 
2984          yield ('slot', self.__field_slot, None) 
2985          yield ('pad', self.__field_pad, None) 
2986   
2987   
2988   
2989   
2990 -class callalarmslotinuseresponse(BaseProtogenClass): 
2991      __fields=['header', 'slot', 'flag', 'pad'] 
2992   
2993 -    def __init__(self, *args, **kwargs): 
2994          dict={} 
2995          # What was supplied to this function 
2996          dict.update(kwargs) 
2997          # Parent constructor 
2998          super(callalarmslotinuseresponse,self).__init__(**dict) 
2999          if self.__class__ is callalarmslotinuseresponse: 
3000              self._update(args,dict) 
3001   
3002   
3003 -    def getfields(self): 
3004          return self.__fields 
3005   
3006   
3007 -    def _update(self, args, kwargs): 
3008          super(callalarmslotinuseresponse,self)._update(args,kwargs) 
3009          keys=kwargs.keys() 
3010          for key in keys: 
3011              if key in self.__fields: 
3012                  setattr(self, key, kwargs[key]) 
3013                  del kwargs[key] 
3014          # Were any unrecognized kwargs passed in? 
3015          if __debug__: 
3016              self._complainaboutunusedargs(callalarmslotinuseresponse,kwargs) 
3017          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
3018          # Make all P fields that haven't already been constructed 
3019   
3020   
3021 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3022          'Writes this packet to the supplied buffer' 
3023          self._bufferstartoffset=buf.getcurrentoffset() 
3024          self.__field_header.writetobuffer(buf) 
3025          self.__field_slot.writetobuffer(buf) 
3026          self.__field_flag.writetobuffer(buf) 
3027          self.__field_pad.writetobuffer(buf) 
3028          self._bufferendoffset=buf.getcurrentoffset() 
3029          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3030   
3031   
3032 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3033          'Reads this packet from the supplied buffer' 
3034          self._bufferstartoffset=buf.getcurrentoffset() 
3035          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3036          self.__field_header=qcpheader() 
3037          self.__field_header.readfrombuffer(buf) 
3038          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
3039          self.__field_slot.readfrombuffer(buf) 
3040          self.__field_flag=UINT(**{'sizeinbytes': 1}) 
3041          self.__field_flag.readfrombuffer(buf) 
3042          self.__field_pad=UNKNOWN() 
3043          self.__field_pad.readfrombuffer(buf) 
3044          self._bufferendoffset=buf.getcurrentoffset() 
3045   
3046   
3047 -    def __getfield_header(self): 
3048          return self.__field_header.getvalue() 
3049   
3050 -    def __setfield_header(self, value): 
3051          if isinstance(value,qcpheader): 
3052              self.__field_header=value 
3053          else: 
3054              self.__field_header=qcpheader(value,) 
3055   
3056 -    def __delfield_header(self): del self.__field_header 
3057   
3058      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
3059   
3060 -    def __getfield_slot(self): 
3061          return self.__field_slot.getvalue() 
3062   
3063 -    def __setfield_slot(self, value): 
3064          if isinstance(value,UINT): 
3065              self.__field_slot=value 
3066          else: 
3067              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
3068   
3069 -    def __delfield_slot(self): del self.__field_slot 
3070   
3071      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
3072   
3073 -    def __getfield_flag(self): 
3074          return self.__field_flag.getvalue() 
3075   
3076 -    def __setfield_flag(self, value): 
3077          if isinstance(value,UINT): 
3078              self.__field_flag=value 
3079          else: 
3080              self.__field_flag=UINT(value,**{'sizeinbytes': 1}) 
3081   
3082 -    def __delfield_flag(self): del self.__field_flag 
3083   
3084      flag=property(__getfield_flag, __setfield_flag, __delfield_flag, None) 
3085   
3086 -    def __getfield_pad(self): 
3087          return self.__field_pad.getvalue() 
3088   
3089 -    def __setfield_pad(self, value): 
3090          if isinstance(value,UNKNOWN): 
3091              self.__field_pad=value 
3092          else: 
3093              self.__field_pad=UNKNOWN(value,) 
3094   
3095 -    def __delfield_pad(self): del self.__field_pad 
3096   
3097      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
3098   
3099 -    def iscontainer(self): 
3100          return True 
3101   
3102 -    def containerelements(self): 
3103          yield ('header', self.__field_header, None) 
3104          yield ('slot', self.__field_slot, None) 
3105          yield ('flag', self.__field_flag, None) 
3106          yield ('pad', self.__field_pad, None) 
3107   
3108   
3109   
3110   
3111 -class callalarmentry(BaseProtogenClass): 
3112      __fields=['slot', 'pad0', 'phonenum', 'phonenum_len', 'date', 'period', 'dom', 'datedup', 'name', 'pad1', 'name_len', 'phonenumbertype', 'phonenumberslot', 'pad2', 'serial', 'pad3', 'ringtone', 'pad4', 'flag'] 
3113   
3114 -    def __init__(self, *args, **kwargs): 
3115          dict={} 
3116          # What was supplied to this function 
3117          dict.update(kwargs) 
3118          # Parent constructor 
3119          super(callalarmentry,self).__init__(**dict) 
3120          if self.__class__ is callalarmentry: 
3121              self._update(args,dict) 
3122   
3123   
3124 -    def getfields(self): 
3125          return self.__fields 
3126   
3127   
3128 -    def _update(self, args, kwargs): 
3129          super(callalarmentry,self)._update(args,kwargs) 
3130          keys=kwargs.keys() 
3131          for key in keys: 
3132              if key in self.__fields: 
3133                  setattr(self, key, kwargs[key]) 
3134                  del kwargs[key] 
3135          # Were any unrecognized kwargs passed in? 
3136          if __debug__: 
3137              self._complainaboutunusedargs(callalarmentry,kwargs) 
3138          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
3139          # Make all P fields that haven't already been constructed 
3140   
3141   
3142 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3143          'Writes this packet to the supplied buffer' 
3144          self._bufferstartoffset=buf.getcurrentoffset() 
3145          self.__field_slot.writetobuffer(buf) 
3146          try: self.__field_pad0 
3147          except: 
3148              self.__field_pad0=UNKNOWN(**{'sizeinbytes': 1}) 
3149          self.__field_pad0.writetobuffer(buf) 
3150          self.__field_phonenum.writetobuffer(buf) 
3151          self.__field_phonenum_len.writetobuffer(buf) 
3152          self.__field_date.writetobuffer(buf) 
3153          self.__field_period.writetobuffer(buf) 
3154          self.__field_dom.writetobuffer(buf) 
3155          self.__field_datedup.writetobuffer(buf) 
3156          self.__field_name.writetobuffer(buf) 
3157          try: self.__field_pad1 
3158          except: 
3159              self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1}) 
3160          self.__field_pad1.writetobuffer(buf) 
3161          self.__field_name_len.writetobuffer(buf) 
3162          self.__field_phonenumbertype.writetobuffer(buf) 
3163          self.__field_phonenumberslot.writetobuffer(buf) 
3164          try: self.__field_pad2 
3165          except: 
3166              self.__field_pad2=UNKNOWN(**{'sizeinbytes': 1}) 
3167          self.__field_pad2.writetobuffer(buf) 
3168          try: self.__field_serial 
3169          except: 
3170              self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 
3171          self.__field_serial.writetobuffer(buf) 
3172          try: self.__field_pad3 
3173          except: 
3174              self.__field_pad3=UNKNOWN(**{'sizeinbytes': 2}) 
3175          self.__field_pad3.writetobuffer(buf) 
3176          try: self.__field_ringtone 
3177          except: 
3178              self.__field_ringtone=UINT(**{'sizeinbytes': 1, 'default': 0xfc}) 
3179          self.__field_ringtone.writetobuffer(buf) 
3180          try: self.__field_pad4 
3181          except: 
3182              self.__field_pad4=UNKNOWN(**{'sizeinbytes': 1}) 
3183          self.__field_pad4.writetobuffer(buf) 
3184          try: self.__field_flag 
3185          except: 
3186              self.__field_flag=UINT(**{'sizeinbytes': 1}) 
3187          self.__field_flag.writetobuffer(buf) 
3188          self._bufferendoffset=buf.getcurrentoffset() 
3189          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3190   
3191   
3192 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3193          'Reads this packet from the supplied buffer' 
3194          self._bufferstartoffset=buf.getcurrentoffset() 
3195          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3196          self.__field_slot=UINT(**{'sizeinbytes': 1}) 
3197          self.__field_slot.readfrombuffer(buf) 
3198          self.__field_pad0=UNKNOWN(**{'sizeinbytes': 1}) 
3199          self.__field_pad0.readfrombuffer(buf) 
3200          self.__field_phonenum=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 
3201          self.__field_phonenum.readfrombuffer(buf) 
3202          self.__field_phonenum_len=UINT(**{'sizeinbytes': 1}) 
3203          self.__field_phonenum_len.readfrombuffer(buf) 
3204          self.__field_date=UINT(**{'sizeinbytes': 4}) 
3205          self.__field_date.readfrombuffer(buf) 
3206          self.__field_period=UINT(**{'sizeinbytes': 1}) 
3207          self.__field_period.readfrombuffer(buf) 
3208          self.__field_dom=UINT(**{'sizeinbytes': 1}) 
3209          self.__field_dom.readfrombuffer(buf) 
3210          self.__field_datedup=UINT(**{'sizeinbytes': 4}) 
3211          self.__field_datedup.readfrombuffer(buf) 
3212          self.__field_name=USTRING(**{'sizeinbytes': 16, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
3213          self.__field_name.readfrombuffer(buf) 
3214          self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1}) 
3215          self.__field_pad1.readfrombuffer(buf) 
3216          self.__field_name_len=UINT(**{'sizeinbytes': 1}) 
3217          self.__field_name_len.readfrombuffer(buf) 
3218          self.__field_phonenumbertype=UINT(**{'sizeinbytes': 1}) 
3219          self.__field_phonenumbertype.readfrombuffer(buf) 
3220          self.__field_phonenumberslot=UINT(**{'sizeinbytes': 2}) 
3221          self.__field_phonenumberslot.readfrombuffer(buf) 
3222          self.__field_pad2=UNKNOWN(**{'sizeinbytes': 1}) 
3223          self.__field_pad2.readfrombuffer(buf) 
3224          self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 
3225          self.__field_serial.readfrombuffer(buf) 
3226          self.__field_pad3=UNKNOWN(**{'sizeinbytes': 2}) 
3227          self.__field_pad3.readfrombuffer(buf) 
3228          self.__field_ringtone=UINT(**{'sizeinbytes': 1, 'default': 0xfc}) 
3229          self.__field_ringtone.readfrombuffer(buf) 
3230          self.__field_pad4=UNKNOWN(**{'sizeinbytes': 1}) 
3231          self.__field_pad4.readfrombuffer(buf) 
3232          self.__field_flag=UINT(**{'sizeinbytes': 1}) 
3233          self.__field_flag.readfrombuffer(buf) 
3234          self._bufferendoffset=buf.getcurrentoffset() 
3235   
3236   
3237 -    def __getfield_slot(self): 
3238          return self.__field_slot.getvalue() 
3239   
3240 -    def __setfield_slot(self, value): 
3241          if isinstance(value,UINT): 
3242              self.__field_slot=value 
3243          else: 
3244              self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 
3245   
3246 -    def __delfield_slot(self): del self.__field_slot 
3247   
3248      slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 
3249   
3250 -    def __getfield_pad0(self): 
3251          try: self.__field_pad0 
3252          except: 
3253              self.__field_pad0=UNKNOWN(**{'sizeinbytes': 1}) 
3254          return self.__field_pad0.getvalue() 
3255   
3256 -    def __setfield_pad0(self, value): 
3257          if isinstance(value,UNKNOWN): 
3258              self.__field_pad0=value 
3259          else: 
3260              self.__field_pad0=UNKNOWN(value,**{'sizeinbytes': 1}) 
3261   
3262 -    def __delfield_pad0(self): del self.__field_pad0 
3263   
3264      pad0=property(__getfield_pad0, __setfield_pad0, __delfield_pad0, "Not the flag?") 
3265   
3266 -    def __getfield_phonenum(self): 
3267          return self.__field_phonenum.getvalue() 
3268   
3269 -    def __setfield_phonenum(self, value): 
3270          if isinstance(value,USTRING): 
3271              self.__field_phonenum=value 
3272          else: 
3273              self.__field_phonenum=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 
3274   
3275 -    def __delfield_phonenum(self): del self.__field_phonenum 
3276   
3277      phonenum=property(__getfield_phonenum, __setfield_phonenum, __delfield_phonenum, None) 
3278   
3279 -    def __getfield_phonenum_len(self): 
3280          return self.__field_phonenum_len.getvalue() 
3281   
3282 -    def __setfield_phonenum_len(self, value): 
3283          if isinstance(value,UINT): 
3284              self.__field_phonenum_len=value 
3285          else: 
3286              self.__field_phonenum_len=UINT(value,**{'sizeinbytes': 1}) 
3287   
3288 -    def __delfield_phonenum_len(self): del self.__field_phonenum_len 
3289   
3290      phonenum_len=property(__getfield_phonenum_len, __setfield_phonenum_len, __delfield_phonenum_len, None) 
3291   
3292 -    def __getfield_date(self): 
3293          return self.__field_date.getvalue() 
3294   
3295 -    def __setfield_date(self, value): 
3296          if isinstance(value,UINT): 
3297              self.__field_date=value 
3298          else: 
3299              self.__field_date=UINT(value,**{'sizeinbytes': 4}) 
3300   
3301 -    def __delfield_date(self): del self.__field_date 
3302   
3303      date=property(__getfield_date, __setfield_date, __delfield_date, "# seconds since Jan 1, 1980 approximately") 
3304   
3305 -    def __getfield_period(self): 
3306          return self.__field_period.getvalue() 
3307   
3308 -    def __setfield_period(self, value): 
3309          if isinstance(value,UINT): 
3310              self.__field_period=value 
3311          else: 
3312              self.__field_period=UINT(value,**{'sizeinbytes': 1}) 
3313   
3314 -    def __delfield_period(self): del self.__field_period 
3315   
3316      period=property(__getfield_period, __setfield_period, __delfield_period, "No, Daily, Weekly, Monthly, Yearly") 
3317   
3318 -    def __getfield_dom(self): 
3319          return self.__field_dom.getvalue() 
3320   
3321 -    def __setfield_dom(self, value): 
3322          if isinstance(value,UINT): 
3323              self.__field_dom=value 
3324          else: 
3325              self.__field_dom=UINT(value,**{'sizeinbytes': 1}) 
3326   
3327 -    def __delfield_dom(self): del self.__field_dom 
3328   
3329      dom=property(__getfield_dom, __setfield_dom, __delfield_dom, "Day of month for the event") 
3330   
3331 -    def __getfield_datedup(self): 
3332          return self.__field_datedup.getvalue() 
3333   
3334 -    def __setfield_datedup(self, value): 
3335          if isinstance(value,UINT): 
3336              self.__field_datedup=value 
3337          else: 
3338              self.__field_datedup=UINT(value,**{'sizeinbytes': 4}) 
3339   
3340 -    def __delfield_datedup(self): del self.__field_datedup 
3341   
3342      datedup=property(__getfield_datedup, __setfield_datedup, __delfield_datedup, "Copy of the date.  Always the same???") 
3343   
3344 -    def __getfield_name(self): 
3345          return self.__field_name.getvalue() 
3346   
3347 -    def __setfield_name(self, value): 
3348          if isinstance(value,USTRING): 
3349              self.__field_name=value 
3350          else: 
3351              self.__field_name=USTRING(value,**{'sizeinbytes': 16, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 
3352   
3353 -    def __delfield_name(self): del self.__field_name 
3354   
3355      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
3356   
3357 -    def __getfield_pad1(self): 
3358          try: self.__field_pad1 
3359          except: 
3360              self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1}) 
3361          return self.__field_pad1.getvalue() 
3362   
3363 -    def __setfield_pad1(self, value): 
3364          if isinstance(value,UNKNOWN): 
3365              self.__field_pad1=value 
3366          else: 
3367              self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 1}) 
3368   
3369 -    def __delfield_pad1(self): del self.__field_pad1 
3370   
3371      pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None) 
3372   
3373 -    def __getfield_name_len(self): 
3374          return self.__field_name_len.getvalue() 
3375   
3376 -    def __setfield_name_len(self, value): 
3377          if isinstance(value,UINT): 
3378              self.__field_name_len=value 
3379          else: 
3380              self.__field_name_len=UINT(value,**{'sizeinbytes': 1}) 
3381   
3382 -    def __delfield_name_len(self): del self.__field_name_len 
3383   
3384      name_len=property(__getfield_name_len, __setfield_name_len, __delfield_name_len, None) 
3385   
3386 -    def __getfield_phonenumbertype(self): 
3387          return self.__field_phonenumbertype.getvalue() 
3388   
3389 -    def __setfield_phonenumbertype(self, value): 
3390          if isinstance(value,UINT): 
3391              self.__field_phonenumbertype=value 
3392          else: 
3393              self.__field_phonenumbertype=UINT(value,**{'sizeinbytes': 1}) 
3394   
3395 -    def __delfield_phonenumbertype(self): del self.__field_phonenumbertype 
3396   
3397      phonenumbertype=property(__getfield_phonenumbertype, __setfield_phonenumbertype, __delfield_phonenumbertype, "1: Home, 2: Work, ...") 
3398   
3399 -    def __getfield_phonenumberslot(self): 
3400          return self.__field_phonenumberslot.getvalue() 
3401   
3402 -    def __setfield_phonenumberslot(self, value): 
3403          if isinstance(value,UINT): 
3404              self.__field_phonenumberslot=value 
3405          else: 
3406              self.__field_phonenumberslot=UINT(value,**{'sizeinbytes': 2}) 
3407   
3408 -    def __delfield_phonenumberslot(self): del self.__field_phonenumberslot 
3409   
3410      phonenumberslot=property(__getfield_phonenumberslot, __setfield_phonenumberslot, __delfield_phonenumberslot, None) 
3411   
3412 -    def __getfield_pad2(self): 
3413          try: self.__field_pad2 
3414          except: 
3415              self.__field_pad2=UNKNOWN(**{'sizeinbytes': 1}) 
3416          return self.__field_pad2.getvalue() 
3417   
3418 -    def __setfield_pad2(self, value): 
3419          if isinstance(value,UNKNOWN): 
3420              self.__field_pad2=value 
3421          else: 
3422              self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 1}) 
3423   
3424 -    def __delfield_pad2(self): del self.__field_pad2 
3425   
3426      pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None) 
3427   
3428 -    def __getfield_serial(self): 
3429          try: self.__field_serial 
3430          except: 
3431              self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 
3432          return self.__field_serial.getvalue() 
3433   
3434 -    def __setfield_serial(self, value): 
3435          if isinstance(value,UINT): 
3436              self.__field_serial=value 
3437          else: 
3438              self.__field_serial=UINT(value,**{'sizeinbytes': 1, 'default': 0}) 
3439   
3440 -    def __delfield_serial(self): del self.__field_serial 
3441   
3442      serial=property(__getfield_serial, __setfield_serial, __delfield_serial, None) 
3443   
3444 -    def __getfield_pad3(self): 
3445          try: self.__field_pad3 
3446          except: 
3447              self.__field_pad3=UNKNOWN(**{'sizeinbytes': 2}) 
3448          return self.__field_pad3.getvalue() 
3449   
3450 -    def __setfield_pad3(self, value): 
3451          if isinstance(value,UNKNOWN): 
3452              self.__field_pad3=value 
3453          else: 
3454              self.__field_pad3=UNKNOWN(value,**{'sizeinbytes': 2}) 
3455   
3456 -    def __delfield_pad3(self): del self.__field_pad3 
3457   
3458      pad3=property(__getfield_pad3, __setfield_pad3, __delfield_pad3, None) 
3459   
3460 -    def __getfield_ringtone(self): 
3461          try: self.__field_ringtone 
3462          except: 
3463              self.__field_ringtone=UINT(**{'sizeinbytes': 1, 'default': 0xfc}) 
3464          return self.__field_ringtone.getvalue() 
3465   
3466 -    def __setfield_ringtone(self, value): 
3467          if isinstance(value,UINT): 
3468              self.__field_ringtone=value 
3469          else: 
3470              self.__field_ringtone=UINT(value,**{'sizeinbytes': 1, 'default': 0xfc}) 
3471   
3472 -    def __delfield_ringtone(self): del self.__field_ringtone 
3473   
3474      ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 
3475   
3476 -    def __getfield_pad4(self): 
3477          try: self.__field_pad4 
3478          except: 
3479              self.__field_pad4=UNKNOWN(**{'sizeinbytes': 1}) 
3480          return self.__field_pad4.getvalue() 
3481   
3482 -    def __setfield_pad4(self, value): 
3483          if isinstance(value,UNKNOWN): 
3484              self.__field_pad4=value 
3485          else: 
3486              self.__field_pad4=UNKNOWN(value,**{'sizeinbytes': 1}) 
3487   
3488 -    def __delfield_pad4(self): del self.__field_pad4 
3489   
3490      pad4=property(__getfield_pad4, __setfield_pad4, __delfield_pad4, " This may be the ringtone.  Need to understand ") 
3491   
3492 -    def __getfield_flag(self): 
3493          try: self.__field_flag 
3494          except: 
3495              self.__field_flag=UINT(**{'sizeinbytes': 1}) 
3496          return self.__field_flag.getvalue() 
3497   
3498 -    def __setfield_flag(self, value): 
3499          if isinstance(value,UINT): 
3500              self.__field_flag=value 
3501          else: 
3502              self.__field_flag=UINT(value,**{'sizeinbytes': 1}) 
3503   
3504 -    def __delfield_flag(self): del self.__field_flag 
3505   
3506      flag=property(__getfield_flag, __setfield_flag, __delfield_flag, None) 
3507   
3508 -    def iscontainer(self): 
3509          return True 
3510   
3511 -    def containerelements(self): 
3512          yield ('slot', self.__field_slot, None) 
3513          yield ('pad0', self.__field_pad0, "Not the flag?") 
3514          yield ('phonenum', self.__field_phonenum, None) 
3515          yield ('phonenum_len', self.__field_phonenum_len, None) 
3516          yield ('date', self.__field_date, "# seconds since Jan 1, 1980 approximately") 
3517          yield ('period', self.__field_period, "No, Daily, Weekly, Monthly, Yearly") 
3518          yield ('dom', self.__field_dom, "Day of month for the event") 
3519          yield ('datedup', self.__field_datedup, "Copy of the date.  Always the same???") 
3520          yield ('name', self.__field_name, None) 
3521          yield ('pad1', self.__field_pad1, None) 
3522          yield ('name_len', self.__field_name_len, None) 
3523          yield ('phonenumbertype', self.__field_phonenumbertype, "1: Home, 2: Work, ...") 
3524          yield ('phonenumberslot', self.__field_phonenumberslot, None) 
3525          yield ('pad2', self.__field_pad2, None) 
3526          yield ('serial', self.__field_serial, None) 
3527          yield ('pad3', self.__field_pad3, None) 
3528          yield ('ringtone', self.__field_ringtone, None) 
3529          yield ('pad4', self.__field_pad4, " This may be the ringtone.  Need to understand ") 
3530          yield ('flag', self.__field_flag, None) 
3531