Source Code for Module phones.p_lgg4015

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