Source Code for Module phones.p_lgc2000

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