PyXR

c:\projects\bitpim\src \ phones \ p_lgg4015.py



0001 # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE
0002 
0003 """Various descriptions of data specific to LG G4015"""
0004 
0005 from prototypes import *
0006 from prototypeslg import *
0007 
0008 # Make all lg stuff available in this module as well
0009 from p_etsi import *
0010 from p_lg import *
0011 
0012 # We use LSB for all integer like fields
0013 UINT=UINTlsb
0014 BOOL=BOOLlsb
0015 
0016 # general constants
0017 MEDIA_RINGTONE=0
0018 MEDIA_WALLPAPER=1
0019 GROUP_INDEX_RANGE=xrange(8)
0020 MIN_RINGTONE_INDEX=0
0021 MAX_RINGTONE_INDEX=19
0022 MIN_WALLPAPER_INDEX=0
0023 MAX_WALLPAPER_INDEX=19
0024 CHARSET_IRA='IRA'
0025 CHARSET_BASE64='Base64'
0026 CHARSET_GSM='GSM'
0027 CHARSET_HEX='HEX'
0028 CHARSET_PCCP437='PCCP437'
0029 CHARSET_PCDN='PCDN'
0030 CHARSET_8859_1='8859-1'
0031 CHARSET_UCS2='UCS2'
0032 
0033 # Calendar constants
0034 CAL_TOTAL_ENTRIES=30
0035 CAL_MIN_INDEX=0
0036 CAL_MAX_INDEX=29
0037 CAL_DESC_LEN=30
0038 
0039 CAL_REP_NONE=0
0040 CAL_REP_DAILY=1
0041 CAL_REP_WEEKLY=2
0042 CAL_REP_MONTHLY=3
0043 CAL_REP_YEARLY=4
0044 
0045 CAL_ALARM_NONE=0
0046 CAL_ALARM_ONTIME=1
0047 CAL_ALARM_15MIN=2
0048 CAL_ALARM_30MIN=3
0049 CAL_ALARM_1HR=4
0050 CAL_ALARM_1DAY=5
0051 CAL_ALARM_VALUE={
0052     CAL_ALARM_NONE: -1,
0053     CAL_ALARM_ONTIME: 0,
0054     CAL_ALARM_15MIN: 15,
0055     CAL_ALARM_30MIN: 30,
0056     CAL_ALARM_1HR: 60,
0057     CAL_ALARM_1DAY: 1440 }
0058 CAL_ALARM_LIST=((1440, CAL_ALARM_1DAY), (60, CAL_ALARM_1HR),
0059                 (30, CAL_ALARM_30MIN), (15, CAL_ALARM_15MIN),
0060                 (0, CAL_ALARM_ONTIME), (-1, CAL_ALARM_NONE))
0061 
0062 # Phonebook constans
0063 PB_MEMORY_SIM='AD'
0064 PB_MEMORY_MAIN='ME'
0065 PB_MEMORY_LAST_DIALED='LD'
0066 PB_MEMORY_LAST_RECEIVED='LR'
0067 PB_MEMORY_LAST_MISSED='LM'
0068 PB_MAIN_TOTAL_ENTRIES=255
0069 PB_MAIN_MIN_INDEX=0
0070 PB_MAIN_MAX_INDEX=254
0071 PB_SIM_TOTAL_ENTRIES=250
0072 PB_SIM_MIN_INDEX=1
0073 PB_SIM_MAX_INDEX=250
0074 PB_NUMBER_LEN=40    # max size of a number string
0075 PB_NAME_LEN=20      # max size of a contact name
0076 PB_EMAIL_LEN=40
0077 PB_MEMO_LEN=50
0078 PB_SIM_NAME_LEN=16
0079 PB_LD_MIN_INDEX=1
0080 PB_LD_MAX_INDEX=10
0081 PB_LR_MIN_INDEX=1
0082 PB_LR_MAX_INDEX=20
0083 PB_LM_MIN_INDEX=1
0084 PB_LM_MAX_INDEX=10
0085 PB_CALL_HISTORY_INFO=(
0086     ('Getting Last Dialed Calls', PB_MEMORY_LAST_DIALED,
0087      PB_LD_MIN_INDEX, PB_LD_MAX_INDEX),
0088     ('Getting Last Received Calls', PB_MEMORY_LAST_RECEIVED,
0089      PB_LR_MIN_INDEX, PB_LR_MAX_INDEX),
0090     ('Getting Missed Calls', PB_MEMORY_LAST_MISSED,
0091      PB_LM_MIN_INDEX, PB_LM_MAX_INDEX))
0092 
0093 # Memo constants
0094 MEMO_MIN_INDEX=0
0095 MEMO_MAX_INDEX=19
0096 MEMO_READ_CMD='+CMDR'
0097 MEMO_WRITE_CMD='+CMDW'
0098 
0099 # SMS Constants
0100 SMS_MEMORY_PHONE='ME'
0101 SMS_MEMORY_SIM='SM'
0102 SMS_MEMORY_SELECT_CMD='+CPMS'
0103 SMS_FORMAT_TEXT=1
0104 SMS_FORMAT_PDU=0
0105 SMS_FORMAT_CMD='+CMGF'
0106 SMS_MSG_REC_UNREAD='REC UNREAD'
0107 SMS_MSG_REC_READ='REC READ'
0108 SMS_MSG_STO_UNSENT='STO UNSENT'
0109 SMS_MSG_STO_SENT='STO SENT'
0110 SMS_MSG_ALL='ALL'
0111 SMS_MSG_LIST_CMD='+CMGL'
0112 
0113 class calendar_read_req(BaseProtogenClass):
0114     __fields=['command', 'start_index', 'end_index']
0115 
0116     def __init__(self, *args, **kwargs):
0117         dict={}
0118         # What was supplied to this function
0119         dict.update(kwargs)
0120         # Parent constructor
0121         super(calendar_read_req,self).__init__(**dict)
0122         if self.__class__ is calendar_read_req:
0123             self._update(args,dict)
0124 
0125 
0126     def getfields(self):
0127         return self.__fields
0128 
0129 
0130     def _update(self, args, kwargs):
0131         super(calendar_read_req,self)._update(args,kwargs)
0132         keys=kwargs.keys()
0133         for key in keys:
0134             if key in self.__fields:
0135                 setattr(self, key, kwargs[key])
0136                 del kwargs[key]
0137         # Were any unrecognized kwargs passed in?
0138         if __debug__:
0139             self._complainaboutunusedargs(calendar_read_req,kwargs)
0140         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0141         # Make all P fields that haven't already been constructed
0142 
0143 
0144     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0145         'Writes this packet to the supplied buffer'
0146         self._bufferstartoffset=buf.getcurrentoffset()
0147         try: self.__field_command
0148         except:
0149             self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CXDR=' })
0150         self.__field_command.writetobuffer(buf)
0151         try: self.__field_start_index
0152         except:
0153             self.__field_start_index=CSVINT()
0154         self.__field_start_index.writetobuffer(buf)
0155         try: self.__field_end_index
0156         except:
0157             self.__field_end_index=CSVINT(**{ 'terminator': None })
0158         self.__field_end_index.writetobuffer(buf)
0159         self._bufferendoffset=buf.getcurrentoffset()
0160         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0161 
0162 
0163     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0164         'Reads this packet from the supplied buffer'
0165         self._bufferstartoffset=buf.getcurrentoffset()
0166         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0167         self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CXDR=' })
0168         self.__field_command.readfrombuffer(buf)
0169         self.__field_start_index=CSVINT()
0170         self.__field_start_index.readfrombuffer(buf)
0171         self.__field_end_index=CSVINT(**{ 'terminator': None })
0172         self.__field_end_index.readfrombuffer(buf)
0173         self._bufferendoffset=buf.getcurrentoffset()
0174 
0175 
0176     def __getfield_command(self):
0177         try: self.__field_command
0178         except:
0179             self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CXDR=' })
0180         return self.__field_command.getvalue()
0181 
0182     def __setfield_command(self, value):
0183         if isinstance(value,USTRING):
0184             self.__field_command=value
0185         else:
0186             self.__field_command=USTRING(value,**{ 'terminator': None, 'default': '+CXDR=' })
0187 
0188     def __delfield_command(self): del self.__field_command
0189 
0190     command=property(__getfield_command, __setfield_command, __delfield_command, None)
0191 
0192     def __getfield_start_index(self):
0193         try: self.__field_start_index
0194         except:
0195             self.__field_start_index=CSVINT()
0196         return self.__field_start_index.getvalue()
0197 
0198     def __setfield_start_index(self, value):
0199         if isinstance(value,CSVINT):
0200             self.__field_start_index=value
0201         else:
0202             self.__field_start_index=CSVINT(value,)
0203 
0204     def __delfield_start_index(self): del self.__field_start_index
0205 
0206     start_index=property(__getfield_start_index, __setfield_start_index, __delfield_start_index, None)
0207 
0208     def __getfield_end_index(self):
0209         try: self.__field_end_index
0210         except:
0211             self.__field_end_index=CSVINT(**{ 'terminator': None })
0212         return self.__field_end_index.getvalue()
0213 
0214     def __setfield_end_index(self, value):
0215         if isinstance(value,CSVINT):
0216             self.__field_end_index=value
0217         else:
0218             self.__field_end_index=CSVINT(value,**{ 'terminator': None })
0219 
0220     def __delfield_end_index(self): del self.__field_end_index
0221 
0222     end_index=property(__getfield_end_index, __setfield_end_index, __delfield_end_index, None)
0223 
0224     def iscontainer(self):
0225         return True
0226 
0227     def containerelements(self):
0228         yield ('command', self.__field_command, None)
0229         yield ('start_index', self.__field_start_index, None)
0230         yield ('end_index', self.__field_end_index, None)
0231 
0232 
0233 
0234 
0235 class calendar_read_resp(BaseProtogenClass):
0236     __fields=['command', 'index', 'repeat', 'alarm', 'date', 'time', 'description']
0237 
0238     def __init__(self, *args, **kwargs):
0239         dict={}
0240         # What was supplied to this function
0241         dict.update(kwargs)
0242         # Parent constructor
0243         super(calendar_read_resp,self).__init__(**dict)
0244         if self.__class__ is calendar_read_resp:
0245             self._update(args,dict)
0246 
0247 
0248     def getfields(self):
0249         return self.__fields
0250 
0251 
0252     def _update(self, args, kwargs):
0253         super(calendar_read_resp,self)._update(args,kwargs)
0254         keys=kwargs.keys()
0255         for key in keys:
0256             if key in self.__fields:
0257                 setattr(self, key, kwargs[key])
0258                 del kwargs[key]
0259         # Were any unrecognized kwargs passed in?
0260         if __debug__:
0261             self._complainaboutunusedargs(calendar_read_resp,kwargs)
0262         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0263         # Make all P fields that haven't already been constructed
0264 
0265 
0266     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0267         'Writes this packet to the supplied buffer'
0268         self._bufferstartoffset=buf.getcurrentoffset()
0269         self.__field_command.writetobuffer(buf)
0270         self.__field_index.writetobuffer(buf)
0271         self.__field_repeat.writetobuffer(buf)
0272         self.__field_alarm.writetobuffer(buf)
0273         self.__field_date.writetobuffer(buf)
0274         self.__field_time.writetobuffer(buf)
0275         self.__field_description.writetobuffer(buf)
0276         self._bufferendoffset=buf.getcurrentoffset()
0277         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0278 
0279 
0280     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0281         'Reads this packet from the supplied buffer'
0282         self._bufferstartoffset=buf.getcurrentoffset()
0283         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0284         self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': ord(' '), 'constant': '+CXDR:'})
0285         self.__field_command.readfrombuffer(buf)
0286         self.__field_index=CSVINT()
0287         self.__field_index.readfrombuffer(buf)
0288         self.__field_repeat=CSVINT()
0289         self.__field_repeat.readfrombuffer(buf)
0290         self.__field_alarm=CSVINT()
0291         self.__field_alarm.readfrombuffer(buf)
0292         self.__field_date=GSMCALDATE()
0293         self.__field_date.readfrombuffer(buf)
0294         self.__field_time=GSMCALTIME()
0295         self.__field_time.readfrombuffer(buf)
0296         self.__field_description=CSVSTRING(**{ 'terminator': None })
0297         self.__field_description.readfrombuffer(buf)
0298         self._bufferendoffset=buf.getcurrentoffset()
0299 
0300 
0301     def __getfield_command(self):
0302         return self.__field_command.getvalue()
0303 
0304     def __setfield_command(self, value):
0305         if isinstance(value,CSVSTRING):
0306             self.__field_command=value
0307         else:
0308             self.__field_command=CSVSTRING(value,**{'quotechar': None, 'terminator': ord(' '), 'constant': '+CXDR:'})
0309 
0310     def __delfield_command(self): del self.__field_command
0311 
0312     command=property(__getfield_command, __setfield_command, __delfield_command, None)
0313 
0314     def __getfield_index(self):
0315         return self.__field_index.getvalue()
0316 
0317     def __setfield_index(self, value):
0318         if isinstance(value,CSVINT):
0319             self.__field_index=value
0320         else:
0321             self.__field_index=CSVINT(value,)
0322 
0323     def __delfield_index(self): del self.__field_index
0324 
0325     index=property(__getfield_index, __setfield_index, __delfield_index, None)
0326 
0327     def __getfield_repeat(self):
0328         return self.__field_repeat.getvalue()
0329 
0330     def __setfield_repeat(self, value):
0331         if isinstance(value,CSVINT):
0332             self.__field_repeat=value
0333         else:
0334             self.__field_repeat=CSVINT(value,)
0335 
0336     def __delfield_repeat(self): del self.__field_repeat
0337 
0338     repeat=property(__getfield_repeat, __setfield_repeat, __delfield_repeat, None)
0339 
0340     def __getfield_alarm(self):
0341         return self.__field_alarm.getvalue()
0342 
0343     def __setfield_alarm(self, value):
0344         if isinstance(value,CSVINT):
0345             self.__field_alarm=value
0346         else:
0347             self.__field_alarm=CSVINT(value,)
0348 
0349     def __delfield_alarm(self): del self.__field_alarm
0350 
0351     alarm=property(__getfield_alarm, __setfield_alarm, __delfield_alarm, None)
0352 
0353     def __getfield_date(self):
0354         return self.__field_date.getvalue()
0355 
0356     def __setfield_date(self, value):
0357         if isinstance(value,GSMCALDATE):
0358             self.__field_date=value
0359         else:
0360             self.__field_date=GSMCALDATE(value,)
0361 
0362     def __delfield_date(self): del self.__field_date
0363 
0364     date=property(__getfield_date, __setfield_date, __delfield_date, None)
0365 
0366     def __getfield_time(self):
0367         return self.__field_time.getvalue()
0368 
0369     def __setfield_time(self, value):
0370         if isinstance(value,GSMCALTIME):
0371             self.__field_time=value
0372         else:
0373             self.__field_time=GSMCALTIME(value,)
0374 
0375     def __delfield_time(self): del self.__field_time
0376 
0377     time=property(__getfield_time, __setfield_time, __delfield_time, None)
0378 
0379     def __getfield_description(self):
0380         return self.__field_description.getvalue()
0381 
0382     def __setfield_description(self, value):
0383         if isinstance(value,CSVSTRING):
0384             self.__field_description=value
0385         else:
0386             self.__field_description=CSVSTRING(value,**{ 'terminator': None })
0387 
0388     def __delfield_description(self): del self.__field_description
0389 
0390     description=property(__getfield_description, __setfield_description, __delfield_description, None)
0391 
0392     def iscontainer(self):
0393         return True
0394 
0395     def containerelements(self):
0396         yield ('command', self.__field_command, None)
0397         yield ('index', self.__field_index, None)
0398         yield ('repeat', self.__field_repeat, None)
0399         yield ('alarm', self.__field_alarm, None)
0400         yield ('date', self.__field_date, None)
0401         yield ('time', self.__field_time, None)
0402         yield ('description', self.__field_description, None)
0403 
0404 
0405 
0406 
0407 class calendar_write_check_req(BaseProtogenClass):
0408     __fields=['command']
0409 
0410     def __init__(self, *args, **kwargs):
0411         dict={}
0412         # What was supplied to this function
0413         dict.update(kwargs)
0414         # Parent constructor
0415         super(calendar_write_check_req,self).__init__(**dict)
0416         if self.__class__ is calendar_write_check_req:
0417             self._update(args,dict)
0418 
0419 
0420     def getfields(self):
0421         return self.__fields
0422 
0423 
0424     def _update(self, args, kwargs):
0425         super(calendar_write_check_req,self)._update(args,kwargs)
0426         keys=kwargs.keys()
0427         for key in keys:
0428             if key in self.__fields:
0429                 setattr(self, key, kwargs[key])
0430                 del kwargs[key]
0431         # Were any unrecognized kwargs passed in?
0432         if __debug__:
0433             self._complainaboutunusedargs(calendar_write_check_req,kwargs)
0434         if len(args):
0435             dict2={ 'terminator': None, 'default': '+CXDW' }
0436             dict2.update(kwargs)
0437             kwargs=dict2
0438             self.__field_command=USTRING(*args,**dict2)
0439         # Make all P fields that haven't already been constructed
0440 
0441 
0442     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0443         'Writes this packet to the supplied buffer'
0444         self._bufferstartoffset=buf.getcurrentoffset()
0445         try: self.__field_command
0446         except:
0447             self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CXDW' })
0448         self.__field_command.writetobuffer(buf)
0449         self._bufferendoffset=buf.getcurrentoffset()
0450         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0451 
0452 
0453     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0454         'Reads this packet from the supplied buffer'
0455         self._bufferstartoffset=buf.getcurrentoffset()
0456         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0457         self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CXDW' })
0458         self.__field_command.readfrombuffer(buf)
0459         self._bufferendoffset=buf.getcurrentoffset()
0460 
0461 
0462     def __getfield_command(self):
0463         try: self.__field_command
0464         except:
0465             self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CXDW' })
0466         return self.__field_command.getvalue()
0467 
0468     def __setfield_command(self, value):
0469         if isinstance(value,USTRING):
0470             self.__field_command=value
0471         else:
0472             self.__field_command=USTRING(value,**{ 'terminator': None, 'default': '+CXDW' })
0473 
0474     def __delfield_command(self): del self.__field_command
0475 
0476     command=property(__getfield_command, __setfield_command, __delfield_command, None)
0477 
0478     def iscontainer(self):
0479         return True
0480 
0481     def containerelements(self):
0482         yield ('command', self.__field_command, None)
0483 
0484 
0485 
0486 
0487 class calendar_write_check_resp(BaseProtogenClass):
0488     __fields=['command', 'index']
0489 
0490     def __init__(self, *args, **kwargs):
0491         dict={}
0492         # What was supplied to this function
0493         dict.update(kwargs)
0494         # Parent constructor
0495         super(calendar_write_check_resp,self).__init__(**dict)
0496         if self.__class__ is calendar_write_check_resp:
0497             self._update(args,dict)
0498 
0499 
0500     def getfields(self):
0501         return self.__fields
0502 
0503 
0504     def _update(self, args, kwargs):
0505         super(calendar_write_check_resp,self)._update(args,kwargs)
0506         keys=kwargs.keys()
0507         for key in keys:
0508             if key in self.__fields:
0509                 setattr(self, key, kwargs[key])
0510                 del kwargs[key]
0511         # Were any unrecognized kwargs passed in?
0512         if __debug__:
0513             self._complainaboutunusedargs(calendar_write_check_resp,kwargs)
0514         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0515         # Make all P fields that haven't already been constructed
0516 
0517 
0518     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0519         'Writes this packet to the supplied buffer'
0520         self._bufferstartoffset=buf.getcurrentoffset()
0521         self.__field_command.writetobuffer(buf)
0522         self.__field_index.writetobuffer(buf)
0523         self._bufferendoffset=buf.getcurrentoffset()
0524         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0525 
0526 
0527     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0528         'Reads this packet from the supplied buffer'
0529         self._bufferstartoffset=buf.getcurrentoffset()
0530         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0531         self.__field_command=USTRING(**{ 'terminator': ord(' '), 'constant': '+CXDW:' })
0532         self.__field_command.readfrombuffer(buf)
0533         self.__field_index=CSVINT(**{ 'terminator': None })
0534         self.__field_index.readfrombuffer(buf)
0535         self._bufferendoffset=buf.getcurrentoffset()
0536 
0537 
0538     def __getfield_command(self):
0539         return self.__field_command.getvalue()
0540 
0541     def __setfield_command(self, value):
0542         if isinstance(value,USTRING):
0543             self.__field_command=value
0544         else:
0545             self.__field_command=USTRING(value,**{ 'terminator': ord(' '), 'constant': '+CXDW:' })
0546 
0547     def __delfield_command(self): del self.__field_command
0548 
0549     command=property(__getfield_command, __setfield_command, __delfield_command, None)
0550 
0551     def __getfield_index(self):
0552         return self.__field_index.getvalue()
0553 
0554     def __setfield_index(self, value):
0555         if isinstance(value,CSVINT):
0556             self.__field_index=value
0557         else:
0558             self.__field_index=CSVINT(value,**{ 'terminator': None })
0559 
0560     def __delfield_index(self): del self.__field_index
0561 
0562     index=property(__getfield_index, __setfield_index, __delfield_index, None)
0563 
0564     def iscontainer(self):
0565         return True
0566 
0567     def containerelements(self):
0568         yield ('command', self.__field_command, None)
0569         yield ('index', self.__field_index, None)
0570 
0571 
0572 
0573 
0574 class calendar_write_req(BaseProtogenClass):
0575     __fields=['command', 'index', 'repeat', 'alarm', 'date', 'time', 'description']
0576 
0577     def __init__(self, *args, **kwargs):
0578         dict={}
0579         # What was supplied to this function
0580         dict.update(kwargs)
0581         # Parent constructor
0582         super(calendar_write_req,self).__init__(**dict)
0583         if self.__class__ is calendar_write_req:
0584             self._update(args,dict)
0585 
0586 
0587     def getfields(self):
0588         return self.__fields
0589 
0590 
0591     def _update(self, args, kwargs):
0592         super(calendar_write_req,self)._update(args,kwargs)
0593         keys=kwargs.keys()
0594         for key in keys:
0595             if key in self.__fields:
0596                 setattr(self, key, kwargs[key])
0597                 del kwargs[key]
0598         # Were any unrecognized kwargs passed in?
0599         if __debug__:
0600             self._complainaboutunusedargs(calendar_write_req,kwargs)
0601         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0602         # Make all P fields that haven't already been constructed
0603 
0604 
0605     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0606         'Writes this packet to the supplied buffer'
0607         self._bufferstartoffset=buf.getcurrentoffset()
0608         try: self.__field_command
0609         except:
0610             self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CXDW=' })
0611         self.__field_command.writetobuffer(buf)
0612         try: self.__field_index
0613         except:
0614             self.__field_index=CSVINT()
0615         self.__field_index.writetobuffer(buf)
0616         try: self.__field_repeat
0617         except:
0618             self.__field_repeat=CSVINT()
0619         self.__field_repeat.writetobuffer(buf)
0620         try: self.__field_alarm
0621         except:
0622             self.__field_alarm=CSVINT()
0623         self.__field_alarm.writetobuffer(buf)
0624         try: self.__field_date
0625         except:
0626             self.__field_date=GSMCALDATE()
0627         self.__field_date.writetobuffer(buf)
0628         try: self.__field_time
0629         except:
0630             self.__field_time=GSMCALTIME()
0631         self.__field_time.writetobuffer(buf)
0632         try: self.__field_description
0633         except:
0634             self.__field_description=CSVSTRING(**{ 'terminator': None,                  'maxsizeinbytes': CAL_DESC_LEN,                  'raiseontruncate': False })
0635         self.__field_description.writetobuffer(buf)
0636         self._bufferendoffset=buf.getcurrentoffset()
0637         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0638 
0639 
0640     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0641         'Reads this packet from the supplied buffer'
0642         self._bufferstartoffset=buf.getcurrentoffset()
0643         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0644         self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CXDW=' })
0645         self.__field_command.readfrombuffer(buf)
0646         self.__field_index=CSVINT()
0647         self.__field_index.readfrombuffer(buf)
0648         self.__field_repeat=CSVINT()
0649         self.__field_repeat.readfrombuffer(buf)
0650         self.__field_alarm=CSVINT()
0651         self.__field_alarm.readfrombuffer(buf)
0652         self.__field_date=GSMCALDATE()
0653         self.__field_date.readfrombuffer(buf)
0654         self.__field_time=GSMCALTIME()
0655         self.__field_time.readfrombuffer(buf)
0656         self.__field_description=CSVSTRING(**{ 'terminator': None,                  'maxsizeinbytes': CAL_DESC_LEN,                  'raiseontruncate': False })
0657         self.__field_description.readfrombuffer(buf)
0658         self._bufferendoffset=buf.getcurrentoffset()
0659 
0660 
0661     def __getfield_command(self):
0662         try: self.__field_command
0663         except:
0664             self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CXDW=' })
0665         return self.__field_command.getvalue()
0666 
0667     def __setfield_command(self, value):
0668         if isinstance(value,USTRING):
0669             self.__field_command=value
0670         else:
0671             self.__field_command=USTRING(value,**{ 'terminator': None, 'default': '+CXDW=' })
0672 
0673     def __delfield_command(self): del self.__field_command
0674 
0675     command=property(__getfield_command, __setfield_command, __delfield_command, None)
0676 
0677     def __getfield_index(self):
0678         try: self.__field_index
0679         except:
0680             self.__field_index=CSVINT()
0681         return self.__field_index.getvalue()
0682 
0683     def __setfield_index(self, value):
0684         if isinstance(value,CSVINT):
0685             self.__field_index=value
0686         else:
0687             self.__field_index=CSVINT(value,)
0688 
0689     def __delfield_index(self): del self.__field_index
0690 
0691     index=property(__getfield_index, __setfield_index, __delfield_index, None)
0692 
0693     def __getfield_repeat(self):
0694         try: self.__field_repeat
0695         except:
0696             self.__field_repeat=CSVINT()
0697         return self.__field_repeat.getvalue()
0698 
0699     def __setfield_repeat(self, value):
0700         if isinstance(value,CSVINT):
0701             self.__field_repeat=value
0702         else:
0703             self.__field_repeat=CSVINT(value,)
0704 
0705     def __delfield_repeat(self): del self.__field_repeat
0706 
0707     repeat=property(__getfield_repeat, __setfield_repeat, __delfield_repeat, None)
0708 
0709     def __getfield_alarm(self):
0710         try: self.__field_alarm
0711         except:
0712             self.__field_alarm=CSVINT()
0713         return self.__field_alarm.getvalue()
0714 
0715     def __setfield_alarm(self, value):
0716         if isinstance(value,CSVINT):
0717             self.__field_alarm=value
0718         else:
0719             self.__field_alarm=CSVINT(value,)
0720 
0721     def __delfield_alarm(self): del self.__field_alarm
0722 
0723     alarm=property(__getfield_alarm, __setfield_alarm, __delfield_alarm, None)
0724 
0725     def __getfield_date(self):
0726         try: self.__field_date
0727         except:
0728             self.__field_date=GSMCALDATE()
0729         return self.__field_date.getvalue()
0730 
0731     def __setfield_date(self, value):
0732         if isinstance(value,GSMCALDATE):
0733             self.__field_date=value
0734         else:
0735             self.__field_date=GSMCALDATE(value,)
0736 
0737     def __delfield_date(self): del self.__field_date
0738 
0739     date=property(__getfield_date, __setfield_date, __delfield_date, None)
0740 
0741     def __getfield_time(self):
0742         try: self.__field_time
0743         except:
0744             self.__field_time=GSMCALTIME()
0745         return self.__field_time.getvalue()
0746 
0747     def __setfield_time(self, value):
0748         if isinstance(value,GSMCALTIME):
0749             self.__field_time=value
0750         else:
0751             self.__field_time=GSMCALTIME(value,)
0752 
0753     def __delfield_time(self): del self.__field_time
0754 
0755     time=property(__getfield_time, __setfield_time, __delfield_time, None)
0756 
0757     def __getfield_description(self):
0758         try: self.__field_description
0759         except:
0760             self.__field_description=CSVSTRING(**{ 'terminator': None,                  'maxsizeinbytes': CAL_DESC_LEN,                  'raiseontruncate': False })
0761         return self.__field_description.getvalue()
0762 
0763     def __setfield_description(self, value):
0764         if isinstance(value,CSVSTRING):
0765             self.__field_description=value
0766         else:
0767             self.__field_description=CSVSTRING(value,**{ 'terminator': None,                  'maxsizeinbytes': CAL_DESC_LEN,                  'raiseontruncate': False })
0768 
0769     def __delfield_description(self): del self.__field_description
0770 
0771     description=property(__getfield_description, __setfield_description, __delfield_description, None)
0772 
0773     def iscontainer(self):
0774         return True
0775 
0776     def containerelements(self):
0777         yield ('command', self.__field_command, None)
0778         yield ('index', self.__field_index, None)
0779         yield ('repeat', self.__field_repeat, None)
0780         yield ('alarm', self.__field_alarm, None)
0781         yield ('date', self.__field_date, None)
0782         yield ('time', self.__field_time, None)
0783         yield ('description', self.__field_description, None)
0784 
0785 
0786 
0787 
0788 class calendar_del_req(BaseProtogenClass):
0789     __fields=['command', 'index']
0790 
0791     def __init__(self, *args, **kwargs):
0792         dict={}
0793         # What was supplied to this function
0794         dict.update(kwargs)
0795         # Parent constructor
0796         super(calendar_del_req,self).__init__(**dict)
0797         if self.__class__ is calendar_del_req:
0798             self._update(args,dict)
0799 
0800 
0801     def getfields(self):
0802         return self.__fields
0803 
0804 
0805     def _update(self, args, kwargs):
0806         super(calendar_del_req,self)._update(args,kwargs)
0807         keys=kwargs.keys()
0808         for key in keys:
0809             if key in self.__fields:
0810                 setattr(self, key, kwargs[key])
0811                 del kwargs[key]
0812         # Were any unrecognized kwargs passed in?
0813         if __debug__:
0814             self._complainaboutunusedargs(calendar_del_req,kwargs)
0815         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0816         # Make all P fields that haven't already been constructed
0817 
0818 
0819     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0820         'Writes this packet to the supplied buffer'
0821         self._bufferstartoffset=buf.getcurrentoffset()
0822         try: self.__field_command
0823         except:
0824             self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CXDW=' })
0825         self.__field_command.writetobuffer(buf)
0826         try: self.__field_index
0827         except:
0828             self.__field_index=CSVINT(**{ 'terminator': None })
0829         self.__field_index.writetobuffer(buf)
0830         self._bufferendoffset=buf.getcurrentoffset()
0831         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0832 
0833 
0834     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0835         'Reads this packet from the supplied buffer'
0836         self._bufferstartoffset=buf.getcurrentoffset()
0837         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0838         self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CXDW=' })
0839         self.__field_command.readfrombuffer(buf)
0840         self.__field_index=CSVINT(**{ 'terminator': None })
0841         self.__field_index.readfrombuffer(buf)
0842         self._bufferendoffset=buf.getcurrentoffset()
0843 
0844 
0845     def __getfield_command(self):
0846         try: self.__field_command
0847         except:
0848             self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CXDW=' })
0849         return self.__field_command.getvalue()
0850 
0851     def __setfield_command(self, value):
0852         if isinstance(value,USTRING):
0853             self.__field_command=value
0854         else:
0855             self.__field_command=USTRING(value,**{ 'terminator': None, 'default': '+CXDW=' })
0856 
0857     def __delfield_command(self): del self.__field_command
0858 
0859     command=property(__getfield_command, __setfield_command, __delfield_command, None)
0860 
0861     def __getfield_index(self):
0862         try: self.__field_index
0863         except:
0864             self.__field_index=CSVINT(**{ 'terminator': None })
0865         return self.__field_index.getvalue()
0866 
0867     def __setfield_index(self, value):
0868         if isinstance(value,CSVINT):
0869             self.__field_index=value
0870         else:
0871             self.__field_index=CSVINT(value,**{ 'terminator': None })
0872 
0873     def __delfield_index(self): del self.__field_index
0874 
0875     index=property(__getfield_index, __setfield_index, __delfield_index, None)
0876 
0877     def iscontainer(self):
0878         return True
0879 
0880     def containerelements(self):
0881         yield ('command', self.__field_command, None)
0882         yield ('index', self.__field_index, None)
0883 
0884 
0885 
0886 
0887 class media_selector_req(BaseProtogenClass):
0888     __fields=['command']
0889 
0890     def __init__(self, *args, **kwargs):
0891         dict={}
0892         # What was supplied to this function
0893         dict.update(kwargs)
0894         # Parent constructor
0895         super(media_selector_req,self).__init__(**dict)
0896         if self.__class__ is media_selector_req:
0897             self._update(args,dict)
0898 
0899 
0900     def getfields(self):
0901         return self.__fields
0902 
0903 
0904     def _update(self, args, kwargs):
0905         super(media_selector_req,self)._update(args,kwargs)
0906         keys=kwargs.keys()
0907         for key in keys:
0908             if key in self.__fields:
0909                 setattr(self, key, kwargs[key])
0910                 del kwargs[key]
0911         # Were any unrecognized kwargs passed in?
0912         if __debug__:
0913             self._complainaboutunusedargs(media_selector_req,kwargs)
0914         if len(args):
0915             dict2={ 'terminator': None, 'default': '+DDLS?' }
0916             dict2.update(kwargs)
0917             kwargs=dict2
0918             self.__field_command=USTRING(*args,**dict2)
0919         # Make all P fields that haven't already been constructed
0920 
0921 
0922     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0923         'Writes this packet to the supplied buffer'
0924         self._bufferstartoffset=buf.getcurrentoffset()
0925         try: self.__field_command
0926         except:
0927             self.__field_command=USTRING(**{ 'terminator': None, 'default': '+DDLS?' })
0928         self.__field_command.writetobuffer(buf)
0929         self._bufferendoffset=buf.getcurrentoffset()
0930         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0931 
0932 
0933     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0934         'Reads this packet from the supplied buffer'
0935         self._bufferstartoffset=buf.getcurrentoffset()
0936         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0937         self.__field_command=USTRING(**{ 'terminator': None, 'default': '+DDLS?' })
0938         self.__field_command.readfrombuffer(buf)
0939         self._bufferendoffset=buf.getcurrentoffset()
0940 
0941 
0942     def __getfield_command(self):
0943         try: self.__field_command
0944         except:
0945             self.__field_command=USTRING(**{ 'terminator': None, 'default': '+DDLS?' })
0946         return self.__field_command.getvalue()
0947 
0948     def __setfield_command(self, value):
0949         if isinstance(value,USTRING):
0950             self.__field_command=value
0951         else:
0952             self.__field_command=USTRING(value,**{ 'terminator': None, 'default': '+DDLS?' })
0953 
0954     def __delfield_command(self): del self.__field_command
0955 
0956     command=property(__getfield_command, __setfield_command, __delfield_command, None)
0957 
0958     def iscontainer(self):
0959         return True
0960 
0961     def containerelements(self):
0962         yield ('command', self.__field_command, None)
0963 
0964 
0965 
0966 
0967 class media_selector_resp(BaseProtogenClass):
0968     __fields=['command', 'media_type']
0969 
0970     def __init__(self, *args, **kwargs):
0971         dict={}
0972         # What was supplied to this function
0973         dict.update(kwargs)
0974         # Parent constructor
0975         super(media_selector_resp,self).__init__(**dict)
0976         if self.__class__ is media_selector_resp:
0977             self._update(args,dict)
0978 
0979 
0980     def getfields(self):
0981         return self.__fields
0982 
0983 
0984     def _update(self, args, kwargs):
0985         super(media_selector_resp,self)._update(args,kwargs)
0986         keys=kwargs.keys()
0987         for key in keys:
0988             if key in self.__fields:
0989                 setattr(self, key, kwargs[key])
0990                 del kwargs[key]
0991         # Were any unrecognized kwargs passed in?
0992         if __debug__:
0993             self._complainaboutunusedargs(media_selector_resp,kwargs)
0994         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0995         # Make all P fields that haven't already been constructed
0996 
0997 
0998     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0999         'Writes this packet to the supplied buffer'
1000         self._bufferstartoffset=buf.getcurrentoffset()
1001         self.__field_command.writetobuffer(buf)
1002         self.__field_media_type.writetobuffer(buf)
1003         self._bufferendoffset=buf.getcurrentoffset()
1004         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1005 
1006 
1007     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1008         'Reads this packet from the supplied buffer'
1009         self._bufferstartoffset=buf.getcurrentoffset()
1010         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1011         self.__field_command=USTRING(**{ 'terminator': ord(' '), 'constant': '+DDLS:' })
1012         self.__field_command.readfrombuffer(buf)
1013         self.__field_media_type=CSVINT(**{ 'terminator': None })
1014         self.__field_media_type.readfrombuffer(buf)
1015         self._bufferendoffset=buf.getcurrentoffset()
1016 
1017 
1018     def __getfield_command(self):
1019         return self.__field_command.getvalue()
1020 
1021     def __setfield_command(self, value):
1022         if isinstance(value,USTRING):
1023             self.__field_command=value
1024         else:
1025             self.__field_command=USTRING(value,**{ 'terminator': ord(' '), 'constant': '+DDLS:' })
1026 
1027     def __delfield_command(self): del self.__field_command
1028 
1029     command=property(__getfield_command, __setfield_command, __delfield_command, None)
1030 
1031     def __getfield_media_type(self):
1032         return self.__field_media_type.getvalue()
1033 
1034     def __setfield_media_type(self, value):
1035         if isinstance(value,CSVINT):
1036             self.__field_media_type=value
1037         else:
1038             self.__field_media_type=CSVINT(value,**{ 'terminator': None })
1039 
1040     def __delfield_media_type(self): del self.__field_media_type
1041 
1042     media_type=property(__getfield_media_type, __setfield_media_type, __delfield_media_type, None)
1043 
1044     def iscontainer(self):
1045         return True
1046 
1047     def containerelements(self):
1048         yield ('command', self.__field_command, None)
1049         yield ('media_type', self.__field_media_type, None)
1050 
1051 
1052 
1053 
1054 class media_selector_set(BaseProtogenClass):
1055     __fields=['command', 'media_type']
1056 
1057     def __init__(self, *args, **kwargs):
1058         dict={}
1059         # What was supplied to this function
1060         dict.update(kwargs)
1061         # Parent constructor
1062         super(media_selector_set,self).__init__(**dict)
1063         if self.__class__ is media_selector_set:
1064             self._update(args,dict)
1065 
1066 
1067     def getfields(self):
1068         return self.__fields
1069 
1070 
1071     def _update(self, args, kwargs):
1072         super(media_selector_set,self)._update(args,kwargs)
1073         keys=kwargs.keys()
1074         for key in keys:
1075             if key in self.__fields:
1076                 setattr(self, key, kwargs[key])
1077                 del kwargs[key]
1078         # Were any unrecognized kwargs passed in?
1079         if __debug__:
1080             self._complainaboutunusedargs(media_selector_set,kwargs)
1081         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1082         # Make all P fields that haven't already been constructed
1083 
1084 
1085     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1086         'Writes this packet to the supplied buffer'
1087         self._bufferstartoffset=buf.getcurrentoffset()
1088         try: self.__field_command
1089         except:
1090             self.__field_command=USTRING(**{ 'terminator': None, 'default': '+DDLS=' })
1091         self.__field_command.writetobuffer(buf)
1092         try: self.__field_media_type
1093         except:
1094             self.__field_media_type=CSVINT(**{ 'terminator': None })
1095         self.__field_media_type.writetobuffer(buf)
1096         self._bufferendoffset=buf.getcurrentoffset()
1097         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1098 
1099 
1100     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1101         'Reads this packet from the supplied buffer'
1102         self._bufferstartoffset=buf.getcurrentoffset()
1103         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1104         self.__field_command=USTRING(**{ 'terminator': None, 'default': '+DDLS=' })
1105         self.__field_command.readfrombuffer(buf)
1106         self.__field_media_type=CSVINT(**{ 'terminator': None })
1107         self.__field_media_type.readfrombuffer(buf)
1108         self._bufferendoffset=buf.getcurrentoffset()
1109 
1110 
1111     def __getfield_command(self):
1112         try: self.__field_command
1113         except:
1114             self.__field_command=USTRING(**{ 'terminator': None, 'default': '+DDLS=' })
1115         return self.__field_command.getvalue()
1116 
1117     def __setfield_command(self, value):
1118         if isinstance(value,USTRING):
1119             self.__field_command=value
1120         else:
1121             self.__field_command=USTRING(value,**{ 'terminator': None, 'default': '+DDLS=' })
1122 
1123     def __delfield_command(self): del self.__field_command
1124 
1125     command=property(__getfield_command, __setfield_command, __delfield_command, None)
1126 
1127     def __getfield_media_type(self):
1128         try: self.__field_media_type
1129         except:
1130             self.__field_media_type=CSVINT(**{ 'terminator': None })
1131         return self.__field_media_type.getvalue()
1132 
1133     def __setfield_media_type(self, value):
1134         if isinstance(value,CSVINT):
1135             self.__field_media_type=value
1136         else:
1137             self.__field_media_type=CSVINT(value,**{ 'terminator': None })
1138 
1139     def __delfield_media_type(self): del self.__field_media_type
1140 
1141     media_type=property(__getfield_media_type, __setfield_media_type, __delfield_media_type, None)
1142 
1143     def iscontainer(self):
1144         return True
1145 
1146     def containerelements(self):
1147         yield ('command', self.__field_command, None)
1148         yield ('media_type', self.__field_media_type, None)
1149 
1150 
1151 
1152 
1153 class media_list_req(BaseProtogenClass):
1154     __fields=['command', 'start_index', 'end_index']
1155 
1156     def __init__(self, *args, **kwargs):
1157         dict={}
1158         # What was supplied to this function
1159         dict.update(kwargs)
1160         # Parent constructor
1161         super(media_list_req,self).__init__(**dict)
1162         if self.__class__ is media_list_req:
1163             self._update(args,dict)
1164 
1165 
1166     def getfields(self):
1167         return self.__fields
1168 
1169 
1170     def _update(self, args, kwargs):
1171         super(media_list_req,self)._update(args,kwargs)
1172         keys=kwargs.keys()
1173         for key in keys:
1174             if key in self.__fields:
1175                 setattr(self, key, kwargs[key])
1176                 del kwargs[key]
1177         # Were any unrecognized kwargs passed in?
1178         if __debug__:
1179             self._complainaboutunusedargs(media_list_req,kwargs)
1180         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1181         # Make all P fields that haven't already been constructed
1182 
1183 
1184     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1185         'Writes this packet to the supplied buffer'
1186         self._bufferstartoffset=buf.getcurrentoffset()
1187         try: self.__field_command
1188         except:
1189             self.__field_command=USTRING(**{ 'terminator': None, 'default': '+DDLR=' })
1190         self.__field_command.writetobuffer(buf)
1191         try: self.__field_start_index
1192         except:
1193             self.__field_start_index=CSVINT()
1194         self.__field_start_index.writetobuffer(buf)
1195         try: self.__field_end_index
1196         except:
1197             self.__field_end_index=CSVINT(**{ 'terminator': None })
1198         self.__field_end_index.writetobuffer(buf)
1199         self._bufferendoffset=buf.getcurrentoffset()
1200         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1201 
1202 
1203     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1204         'Reads this packet from the supplied buffer'
1205         self._bufferstartoffset=buf.getcurrentoffset()
1206         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1207         self.__field_command=USTRING(**{ 'terminator': None, 'default': '+DDLR=' })
1208         self.__field_command.readfrombuffer(buf)
1209         self.__field_start_index=CSVINT()
1210         self.__field_start_index.readfrombuffer(buf)
1211         self.__field_end_index=CSVINT(**{ 'terminator': None })
1212         self.__field_end_index.readfrombuffer(buf)
1213         self._bufferendoffset=buf.getcurrentoffset()
1214 
1215 
1216     def __getfield_command(self):
1217         try: self.__field_command
1218         except:
1219             self.__field_command=USTRING(**{ 'terminator': None, 'default': '+DDLR=' })
1220         return self.__field_command.getvalue()
1221 
1222     def __setfield_command(self, value):
1223         if isinstance(value,USTRING):
1224             self.__field_command=value
1225         else:
1226             self.__field_command=USTRING(value,**{ 'terminator': None, 'default': '+DDLR=' })
1227 
1228     def __delfield_command(self): del self.__field_command
1229 
1230     command=property(__getfield_command, __setfield_command, __delfield_command, None)
1231 
1232     def __getfield_start_index(self):
1233         try: self.__field_start_index
1234         except:
1235             self.__field_start_index=CSVINT()
1236         return self.__field_start_index.getvalue()
1237 
1238     def __setfield_start_index(self, value):
1239         if isinstance(value,CSVINT):
1240             self.__field_start_index=value
1241         else:
1242             self.__field_start_index=CSVINT(value,)
1243 
1244     def __delfield_start_index(self): del self.__field_start_index
1245 
1246     start_index=property(__getfield_start_index, __setfield_start_index, __delfield_start_index, None)
1247 
1248     def __getfield_end_index(self):
1249         try: self.__field_end_index
1250         except:
1251             self.__field_end_index=CSVINT(**{ 'terminator': None })
1252         return self.__field_end_index.getvalue()
1253 
1254     def __setfield_end_index(self, value):
1255         if isinstance(value,CSVINT):
1256             self.__field_end_index=value
1257         else:
1258             self.__field_end_index=CSVINT(value,**{ 'terminator': None })
1259 
1260     def __delfield_end_index(self): del self.__field_end_index
1261 
1262     end_index=property(__getfield_end_index, __setfield_end_index, __delfield_end_index, None)
1263 
1264     def iscontainer(self):
1265         return True
1266 
1267     def containerelements(self):
1268         yield ('command', self.__field_command, None)
1269         yield ('start_index', self.__field_start_index, None)
1270         yield ('end_index', self.__field_end_index, None)
1271 
1272 
1273 
1274 
1275 class media_list_resp(BaseProtogenClass):
1276     __fields=['command', 'index', 'file_name', 'media_name']
1277 
1278     def __init__(self, *args, **kwargs):
1279         dict={}
1280         # What was supplied to this function
1281         dict.update(kwargs)
1282         # Parent constructor
1283         super(media_list_resp,self).__init__(**dict)
1284         if self.__class__ is media_list_resp:
1285             self._update(args,dict)
1286 
1287 
1288     def getfields(self):
1289         return self.__fields
1290 
1291 
1292     def _update(self, args, kwargs):
1293         super(media_list_resp,self)._update(args,kwargs)
1294         keys=kwargs.keys()
1295         for key in keys:
1296             if key in self.__fields:
1297                 setattr(self, key, kwargs[key])
1298                 del kwargs[key]
1299         # Were any unrecognized kwargs passed in?
1300         if __debug__:
1301             self._complainaboutunusedargs(media_list_resp,kwargs)
1302         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1303         # Make all P fields that haven't already been constructed
1304 
1305 
1306     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1307         'Writes this packet to the supplied buffer'
1308         self._bufferstartoffset=buf.getcurrentoffset()
1309         self.__field_command.writetobuffer(buf)
1310         self.__field_index.writetobuffer(buf)
1311         self.__field_file_name.writetobuffer(buf)
1312         self.__field_media_name.writetobuffer(buf)
1313         self._bufferendoffset=buf.getcurrentoffset()
1314         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1315 
1316 
1317     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1318         'Reads this packet from the supplied buffer'
1319         self._bufferstartoffset=buf.getcurrentoffset()
1320         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1321         self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': ord(' '), 'constant': '+DDLR:'})
1322         self.__field_command.readfrombuffer(buf)
1323         self.__field_index=CSVINT()
1324         self.__field_index.readfrombuffer(buf)
1325         self.__field_file_name=CSVSTRING()
1326         self.__field_file_name.readfrombuffer(buf)
1327         self.__field_media_name=CSVSTRING(**{ 'terminator': None })
1328         self.__field_media_name.readfrombuffer(buf)
1329         self._bufferendoffset=buf.getcurrentoffset()
1330 
1331 
1332     def __getfield_command(self):
1333         return self.__field_command.getvalue()
1334 
1335     def __setfield_command(self, value):
1336         if isinstance(value,CSVSTRING):
1337             self.__field_command=value
1338         else:
1339             self.__field_command=CSVSTRING(value,**{'quotechar': None, 'terminator': ord(' '), 'constant': '+DDLR:'})
1340 
1341     def __delfield_command(self): del self.__field_command
1342 
1343     command=property(__getfield_command, __setfield_command, __delfield_command, None)
1344 
1345     def __getfield_index(self):
1346         return self.__field_index.getvalue()
1347 
1348     def __setfield_index(self, value):
1349         if isinstance(value,CSVINT):
1350             self.__field_index=value
1351         else:
1352             self.__field_index=CSVINT(value,)
1353 
1354     def __delfield_index(self): del self.__field_index
1355 
1356     index=property(__getfield_index, __setfield_index, __delfield_index, None)
1357 
1358     def __getfield_file_name(self):
1359         return self.__field_file_name.getvalue()
1360 
1361     def __setfield_file_name(self, value):
1362         if isinstance(value,CSVSTRING):
1363             self.__field_file_name=value
1364         else:
1365             self.__field_file_name=CSVSTRING(value,)
1366 
1367     def __delfield_file_name(self): del self.__field_file_name
1368 
1369     file_name=property(__getfield_file_name, __setfield_file_name, __delfield_file_name, None)
1370 
1371     def __getfield_media_name(self):
1372         return self.__field_media_name.getvalue()
1373 
1374     def __setfield_media_name(self, value):
1375         if isinstance(value,CSVSTRING):
1376             self.__field_media_name=value
1377         else:
1378             self.__field_media_name=CSVSTRING(value,**{ 'terminator': None })
1379 
1380     def __delfield_media_name(self): del self.__field_media_name
1381 
1382     media_name=property(__getfield_media_name, __setfield_media_name, __delfield_media_name, None)
1383 
1384     def iscontainer(self):
1385         return True
1386 
1387     def containerelements(self):
1388         yield ('command', self.__field_command, None)
1389         yield ('index', self.__field_index, None)
1390         yield ('file_name', self.__field_file_name, None)
1391         yield ('media_name', self.__field_media_name, None)
1392 
1393 
1394 
1395 
1396 class del_media_req(BaseProtogenClass):
1397     __fields=['command', 'file_name']
1398 
1399     def __init__(self, *args, **kwargs):
1400         dict={}
1401         # What was supplied to this function
1402         dict.update(kwargs)
1403         # Parent constructor
1404         super(del_media_req,self).__init__(**dict)
1405         if self.__class__ is del_media_req:
1406             self._update(args,dict)
1407 
1408 
1409     def getfields(self):
1410         return self.__fields
1411 
1412 
1413     def _update(self, args, kwargs):
1414         super(del_media_req,self)._update(args,kwargs)
1415         keys=kwargs.keys()
1416         for key in keys:
1417             if key in self.__fields:
1418                 setattr(self, key, kwargs[key])
1419                 del kwargs[key]
1420         # Were any unrecognized kwargs passed in?
1421         if __debug__:
1422             self._complainaboutunusedargs(del_media_req,kwargs)
1423         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1424         # Make all P fields that haven't already been constructed
1425 
1426 
1427     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1428         'Writes this packet to the supplied buffer'
1429         self._bufferstartoffset=buf.getcurrentoffset()
1430         try: self.__field_command
1431         except:
1432             self.__field_command=USTRING(**{ 'terminator': None, 'default': '+DDLD=0,' })
1433         self.__field_command.writetobuffer(buf)
1434         try: self.__field_file_name
1435         except:
1436             self.__field_file_name=CSVSTRING(**{ 'terminator': None })
1437         self.__field_file_name.writetobuffer(buf)
1438         self._bufferendoffset=buf.getcurrentoffset()
1439         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1440 
1441 
1442     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1443         'Reads this packet from the supplied buffer'
1444         self._bufferstartoffset=buf.getcurrentoffset()
1445         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1446         self.__field_command=USTRING(**{ 'terminator': None, 'default': '+DDLD=0,' })
1447         self.__field_command.readfrombuffer(buf)
1448         self.__field_file_name=CSVSTRING(**{ 'terminator': None })
1449         self.__field_file_name.readfrombuffer(buf)
1450         self._bufferendoffset=buf.getcurrentoffset()
1451 
1452 
1453     def __getfield_command(self):
1454         try: self.__field_command
1455         except:
1456             self.__field_command=USTRING(**{ 'terminator': None, 'default': '+DDLD=0,' })
1457         return self.__field_command.getvalue()
1458 
1459     def __setfield_command(self, value):
1460         if isinstance(value,USTRING):
1461             self.__field_command=value
1462         else:
1463             self.__field_command=USTRING(value,**{ 'terminator': None, 'default': '+DDLD=0,' })
1464 
1465     def __delfield_command(self): del self.__field_command
1466 
1467     command=property(__getfield_command, __setfield_command, __delfield_command, None)
1468 
1469     def __getfield_file_name(self):
1470         try: self.__field_file_name
1471         except:
1472             self.__field_file_name=CSVSTRING(**{ 'terminator': None })
1473         return self.__field_file_name.getvalue()
1474 
1475     def __setfield_file_name(self, value):
1476         if isinstance(value,CSVSTRING):
1477             self.__field_file_name=value
1478         else:
1479             self.__field_file_name=CSVSTRING(value,**{ 'terminator': None })
1480 
1481     def __delfield_file_name(self): del self.__field_file_name
1482 
1483     file_name=property(__getfield_file_name, __setfield_file_name, __delfield_file_name, None)
1484 
1485     def iscontainer(self):
1486         return True
1487 
1488     def containerelements(self):
1489         yield ('command', self.__field_command, None)
1490         yield ('file_name', self.__field_file_name, None)
1491 
1492 
1493 
1494 
1495 class write_media_req(BaseProtogenClass):
1496     __fields=['command', 'index', 'file_name', 'media_name', 'data_len', 'media_type', 'dunno1', 'dunno2', 'dunno3', 'dunno4']
1497 
1498     def __init__(self, *args, **kwargs):
1499         dict={}
1500         # What was supplied to this function
1501         dict.update(kwargs)
1502         # Parent constructor
1503         super(write_media_req,self).__init__(**dict)
1504         if self.__class__ is write_media_req:
1505             self._update(args,dict)
1506 
1507 
1508     def getfields(self):
1509         return self.__fields
1510 
1511 
1512     def _update(self, args, kwargs):
1513         super(write_media_req,self)._update(args,kwargs)
1514         keys=kwargs.keys()
1515         for key in keys:
1516             if key in self.__fields:
1517                 setattr(self, key, kwargs[key])
1518                 del kwargs[key]
1519         # Were any unrecognized kwargs passed in?
1520         if __debug__:
1521             self._complainaboutunusedargs(write_media_req,kwargs)
1522         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1523         # Make all P fields that haven't already been constructed
1524 
1525 
1526     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1527         'Writes this packet to the supplied buffer'
1528         self._bufferstartoffset=buf.getcurrentoffset()
1529         try: self.__field_command
1530         except:
1531             self.__field_command=USTRING(**{ 'terminator': None, 'default': '+DDLW=' })
1532         self.__field_command.writetobuffer(buf)
1533         try: self.__field_index
1534         except:
1535             self.__field_index=CSVINT()
1536         self.__field_index.writetobuffer(buf)
1537         try: self.__field_file_name
1538         except:
1539             self.__field_file_name=CSVSTRING()
1540         self.__field_file_name.writetobuffer(buf)
1541         try: self.__field_media_name
1542         except:
1543             self.__field_media_name=CSVSTRING()
1544         self.__field_media_name.writetobuffer(buf)
1545         self.__field_data_len.writetobuffer(buf)
1546         self.__field_media_type.writetobuffer(buf)
1547         try: self.__field_dunno1
1548         except:
1549             self.__field_dunno1=CSVINT(**{ 'default': 0 })
1550         self.__field_dunno1.writetobuffer(buf)
1551         try: self.__field_dunno2
1552         except:
1553             self.__field_dunno2=CSVINT(**{ 'default': 0 })
1554         self.__field_dunno2.writetobuffer(buf)
1555         try: self.__field_dunno3
1556         except:
1557             self.__field_dunno3=CSVINT(**{ 'default': 0 })
1558         self.__field_dunno3.writetobuffer(buf)
1559         try: self.__field_dunno4
1560         except:
1561             self.__field_dunno4=CSVINT(**{ 'default': 0, 'terminator': ord('\r') })
1562         self.__field_dunno4.writetobuffer(buf)
1563         self._bufferendoffset=buf.getcurrentoffset()
1564         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1565 
1566 
1567     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1568         'Reads this packet from the supplied buffer'
1569         self._bufferstartoffset=buf.getcurrentoffset()
1570         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1571         self.__field_command=USTRING(**{ 'terminator': None, 'default': '+DDLW=' })
1572         self.__field_command.readfrombuffer(buf)
1573         self.__field_index=CSVINT()
1574         self.__field_index.readfrombuffer(buf)
1575         self.__field_file_name=CSVSTRING()
1576         self.__field_file_name.readfrombuffer(buf)
1577         self.__field_media_name=CSVSTRING()
1578         self.__field_media_name.readfrombuffer(buf)
1579         self.__field_data_len=CSVINT()
1580         self.__field_data_len.readfrombuffer(buf)
1581         self.__field_media_type=CSVINT()
1582         self.__field_media_type.readfrombuffer(buf)
1583         self.__field_dunno1=CSVINT(**{ 'default': 0 })
1584         self.__field_dunno1.readfrombuffer(buf)
1585         self.__field_dunno2=CSVINT(**{ 'default': 0 })
1586         self.__field_dunno2.readfrombuffer(buf)
1587         self.__field_dunno3=CSVINT(**{ 'default': 0 })
1588         self.__field_dunno3.readfrombuffer(buf)
1589         self.__field_dunno4=CSVINT(**{ 'default': 0, 'terminator': ord('\r') })
1590         self.__field_dunno4.readfrombuffer(buf)
1591         self._bufferendoffset=buf.getcurrentoffset()
1592 
1593 
1594     def __getfield_command(self):
1595         try: self.__field_command
1596         except:
1597             self.__field_command=USTRING(**{ 'terminator': None, 'default': '+DDLW=' })
1598         return self.__field_command.getvalue()
1599 
1600     def __setfield_command(self, value):
1601         if isinstance(value,USTRING):
1602             self.__field_command=value
1603         else:
1604             self.__field_command=USTRING(value,**{ 'terminator': None, 'default': '+DDLW=' })
1605 
1606     def __delfield_command(self): del self.__field_command
1607 
1608     command=property(__getfield_command, __setfield_command, __delfield_command, None)
1609 
1610     def __getfield_index(self):
1611         try: self.__field_index
1612         except:
1613             self.__field_index=CSVINT()
1614         return self.__field_index.getvalue()
1615 
1616     def __setfield_index(self, value):
1617         if isinstance(value,CSVINT):
1618             self.__field_index=value
1619         else:
1620             self.__field_index=CSVINT(value,)
1621 
1622     def __delfield_index(self): del self.__field_index
1623 
1624     index=property(__getfield_index, __setfield_index, __delfield_index, None)
1625 
1626     def __getfield_file_name(self):
1627         try: self.__field_file_name
1628         except:
1629             self.__field_file_name=CSVSTRING()
1630         return self.__field_file_name.getvalue()
1631 
1632     def __setfield_file_name(self, value):
1633         if isinstance(value,CSVSTRING):
1634             self.__field_file_name=value
1635         else:
1636             self.__field_file_name=CSVSTRING(value,)
1637 
1638     def __delfield_file_name(self): del self.__field_file_name
1639 
1640     file_name=property(__getfield_file_name, __setfield_file_name, __delfield_file_name, None)
1641 
1642     def __getfield_media_name(self):
1643         try: self.__field_media_name
1644         except:
1645             self.__field_media_name=CSVSTRING()
1646         return self.__field_media_name.getvalue()
1647 
1648     def __setfield_media_name(self, value):
1649         if isinstance(value,CSVSTRING):
1650             self.__field_media_name=value
1651         else:
1652             self.__field_media_name=CSVSTRING(value,)
1653 
1654     def __delfield_media_name(self): del self.__field_media_name
1655 
1656     media_name=property(__getfield_media_name, __setfield_media_name, __delfield_media_name, None)
1657 
1658     def __getfield_data_len(self):
1659         return self.__field_data_len.getvalue()
1660 
1661     def __setfield_data_len(self, value):
1662         if isinstance(value,CSVINT):
1663             self.__field_data_len=value
1664         else:
1665             self.__field_data_len=CSVINT(value,)
1666 
1667     def __delfield_data_len(self): del self.__field_data_len
1668 
1669     data_len=property(__getfield_data_len, __setfield_data_len, __delfield_data_len, None)
1670 
1671     def __getfield_media_type(self):
1672         return self.__field_media_type.getvalue()
1673 
1674     def __setfield_media_type(self, value):
1675         if isinstance(value,CSVINT):
1676             self.__field_media_type=value
1677         else:
1678             self.__field_media_type=CSVINT(value,)
1679 
1680     def __delfield_media_type(self): del self.__field_media_type
1681 
1682     media_type=property(__getfield_media_type, __setfield_media_type, __delfield_media_type, None)
1683 
1684     def __getfield_dunno1(self):
1685         try: self.__field_dunno1
1686         except:
1687             self.__field_dunno1=CSVINT(**{ 'default': 0 })
1688         return self.__field_dunno1.getvalue()
1689 
1690     def __setfield_dunno1(self, value):
1691         if isinstance(value,CSVINT):
1692             self.__field_dunno1=value
1693         else:
1694             self.__field_dunno1=CSVINT(value,**{ 'default': 0 })
1695 
1696     def __delfield_dunno1(self): del self.__field_dunno1
1697 
1698     dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None)
1699 
1700     def __getfield_dunno2(self):
1701         try: self.__field_dunno2
1702         except:
1703             self.__field_dunno2=CSVINT(**{ 'default': 0 })
1704         return self.__field_dunno2.getvalue()
1705 
1706     def __setfield_dunno2(self, value):
1707         if isinstance(value,CSVINT):
1708             self.__field_dunno2=value
1709         else:
1710             self.__field_dunno2=CSVINT(value,**{ 'default': 0 })
1711 
1712     def __delfield_dunno2(self): del self.__field_dunno2
1713 
1714     dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None)
1715 
1716     def __getfield_dunno3(self):
1717         try: self.__field_dunno3
1718         except:
1719             self.__field_dunno3=CSVINT(**{ 'default': 0 })
1720         return self.__field_dunno3.getvalue()
1721 
1722     def __setfield_dunno3(self, value):
1723         if isinstance(value,CSVINT):
1724             self.__field_dunno3=value
1725         else:
1726             self.__field_dunno3=CSVINT(value,**{ 'default': 0 })
1727 
1728     def __delfield_dunno3(self): del self.__field_dunno3
1729 
1730     dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None)
1731 
1732     def __getfield_dunno4(self):
1733         try: self.__field_dunno4
1734         except:
1735             self.__field_dunno4=CSVINT(**{ 'default': 0, 'terminator': ord('\r') })
1736         return self.__field_dunno4.getvalue()
1737 
1738     def __setfield_dunno4(self, value):
1739         if isinstance(value,CSVINT):
1740             self.__field_dunno4=value
1741         else:
1742             self.__field_dunno4=CSVINT(value,**{ 'default': 0, 'terminator': ord('\r') })
1743 
1744     def __delfield_dunno4(self): del self.__field_dunno4
1745 
1746     dunno4=property(__getfield_dunno4, __setfield_dunno4, __delfield_dunno4, None)
1747 
1748     def iscontainer(self):
1749         return True
1750 
1751     def containerelements(self):
1752         yield ('command', self.__field_command, None)
1753         yield ('index', self.__field_index, None)
1754         yield ('file_name', self.__field_file_name, None)
1755         yield ('media_name', self.__field_media_name, None)
1756         yield ('data_len', self.__field_data_len, None)
1757         yield ('media_type', self.__field_media_type, None)
1758         yield ('dunno1', self.__field_dunno1, None)
1759         yield ('dunno2', self.__field_dunno2, None)
1760         yield ('dunno3', self.__field_dunno3, None)
1761         yield ('dunno4', self.__field_dunno4, None)
1762 
1763 
1764 
1765 
1766 class list_group_req(BaseProtogenClass):
1767     __fields=['command', 'start_index', 'end_index']
1768 
1769     def __init__(self, *args, **kwargs):
1770         dict={}
1771         # What was supplied to this function
1772         dict.update(kwargs)
1773         # Parent constructor
1774         super(list_group_req,self).__init__(**dict)
1775         if self.__class__ is list_group_req:
1776             self._update(args,dict)
1777 
1778 
1779     def getfields(self):
1780         return self.__fields
1781 
1782 
1783     def _update(self, args, kwargs):
1784         super(list_group_req,self)._update(args,kwargs)
1785         keys=kwargs.keys()
1786         for key in keys:
1787             if key in self.__fields:
1788                 setattr(self, key, kwargs[key])
1789                 del kwargs[key]
1790         # Were any unrecognized kwargs passed in?
1791         if __debug__:
1792             self._complainaboutunusedargs(list_group_req,kwargs)
1793         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1794         # Make all P fields that haven't already been constructed
1795 
1796 
1797     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1798         'Writes this packet to the supplied buffer'
1799         self._bufferstartoffset=buf.getcurrentoffset()
1800         try: self.__field_command
1801         except:
1802             self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CPGR=' })
1803         self.__field_command.writetobuffer(buf)
1804         try: self.__field_start_index
1805         except:
1806             self.__field_start_index=CSVINT()
1807         self.__field_start_index.writetobuffer(buf)
1808         try: self.__field_end_index
1809         except:
1810             self.__field_end_index=CSVINT(**{ 'terminator': None })
1811         self.__field_end_index.writetobuffer(buf)
1812         self._bufferendoffset=buf.getcurrentoffset()
1813         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1814 
1815 
1816     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1817         'Reads this packet from the supplied buffer'
1818         self._bufferstartoffset=buf.getcurrentoffset()
1819         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1820         self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CPGR=' })
1821         self.__field_command.readfrombuffer(buf)
1822         self.__field_start_index=CSVINT()
1823         self.__field_start_index.readfrombuffer(buf)
1824         self.__field_end_index=CSVINT(**{ 'terminator': None })
1825         self.__field_end_index.readfrombuffer(buf)
1826         self._bufferendoffset=buf.getcurrentoffset()
1827 
1828 
1829     def __getfield_command(self):
1830         try: self.__field_command
1831         except:
1832             self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CPGR=' })
1833         return self.__field_command.getvalue()
1834 
1835     def __setfield_command(self, value):
1836         if isinstance(value,USTRING):
1837             self.__field_command=value
1838         else:
1839             self.__field_command=USTRING(value,**{ 'terminator': None, 'default': '+CPGR=' })
1840 
1841     def __delfield_command(self): del self.__field_command
1842 
1843     command=property(__getfield_command, __setfield_command, __delfield_command, None)
1844 
1845     def __getfield_start_index(self):
1846         try: self.__field_start_index
1847         except:
1848             self.__field_start_index=CSVINT()
1849         return self.__field_start_index.getvalue()
1850 
1851     def __setfield_start_index(self, value):
1852         if isinstance(value,CSVINT):
1853             self.__field_start_index=value
1854         else:
1855             self.__field_start_index=CSVINT(value,)
1856 
1857     def __delfield_start_index(self): del self.__field_start_index
1858 
1859     start_index=property(__getfield_start_index, __setfield_start_index, __delfield_start_index, None)
1860 
1861     def __getfield_end_index(self):
1862         try: self.__field_end_index
1863         except:
1864             self.__field_end_index=CSVINT(**{ 'terminator': None })
1865         return self.__field_end_index.getvalue()
1866 
1867     def __setfield_end_index(self, value):
1868         if isinstance(value,CSVINT):
1869             self.__field_end_index=value
1870         else:
1871             self.__field_end_index=CSVINT(value,**{ 'terminator': None })
1872 
1873     def __delfield_end_index(self): del self.__field_end_index
1874 
1875     end_index=property(__getfield_end_index, __setfield_end_index, __delfield_end_index, None)
1876 
1877     def iscontainer(self):
1878         return True
1879 
1880     def containerelements(self):
1881         yield ('command', self.__field_command, None)
1882         yield ('start_index', self.__field_start_index, None)
1883         yield ('end_index', self.__field_end_index, None)
1884 
1885 
1886 
1887 
1888 class list_group_resp(BaseProtogenClass):
1889     __fields=['command', 'index', 'group_name']
1890 
1891     def __init__(self, *args, **kwargs):
1892         dict={}
1893         # What was supplied to this function
1894         dict.update(kwargs)
1895         # Parent constructor
1896         super(list_group_resp,self).__init__(**dict)
1897         if self.__class__ is list_group_resp:
1898             self._update(args,dict)
1899 
1900 
1901     def getfields(self):
1902         return self.__fields
1903 
1904 
1905     def _update(self, args, kwargs):
1906         super(list_group_resp,self)._update(args,kwargs)
1907         keys=kwargs.keys()
1908         for key in keys:
1909             if key in self.__fields:
1910                 setattr(self, key, kwargs[key])
1911                 del kwargs[key]
1912         # Were any unrecognized kwargs passed in?
1913         if __debug__:
1914             self._complainaboutunusedargs(list_group_resp,kwargs)
1915         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1916         # Make all P fields that haven't already been constructed
1917 
1918 
1919     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1920         'Writes this packet to the supplied buffer'
1921         self._bufferstartoffset=buf.getcurrentoffset()
1922         self.__field_command.writetobuffer(buf)
1923         self.__field_index.writetobuffer(buf)
1924         self.__field_group_name.writetobuffer(buf)
1925         self._bufferendoffset=buf.getcurrentoffset()
1926         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1927 
1928 
1929     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1930         'Reads this packet from the supplied buffer'
1931         self._bufferstartoffset=buf.getcurrentoffset()
1932         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1933         self.__field_command=USTRING(**{ 'terminator': ord(' '), 'constant': '+CPGR:' })
1934         self.__field_command.readfrombuffer(buf)
1935         self.__field_index=CSVINT()
1936         self.__field_index.readfrombuffer(buf)
1937         self.__field_group_name=CSVSTRING(**{ 'terminator': None })
1938         self.__field_group_name.readfrombuffer(buf)
1939         self._bufferendoffset=buf.getcurrentoffset()
1940 
1941 
1942     def __getfield_command(self):
1943         return self.__field_command.getvalue()
1944 
1945     def __setfield_command(self, value):
1946         if isinstance(value,USTRING):
1947             self.__field_command=value
1948         else:
1949             self.__field_command=USTRING(value,**{ 'terminator': ord(' '), 'constant': '+CPGR:' })
1950 
1951     def __delfield_command(self): del self.__field_command
1952 
1953     command=property(__getfield_command, __setfield_command, __delfield_command, None)
1954 
1955     def __getfield_index(self):
1956         return self.__field_index.getvalue()
1957 
1958     def __setfield_index(self, value):
1959         if isinstance(value,CSVINT):
1960             self.__field_index=value
1961         else:
1962             self.__field_index=CSVINT(value,)
1963 
1964     def __delfield_index(self): del self.__field_index
1965 
1966     index=property(__getfield_index, __setfield_index, __delfield_index, None)
1967 
1968     def __getfield_group_name(self):
1969         return self.__field_group_name.getvalue()
1970 
1971     def __setfield_group_name(self, value):
1972         if isinstance(value,CSVSTRING):
1973             self.__field_group_name=value
1974         else:
1975             self.__field_group_name=CSVSTRING(value,**{ 'terminator': None })
1976 
1977     def __delfield_group_name(self): del self.__field_group_name
1978 
1979     group_name=property(__getfield_group_name, __setfield_group_name, __delfield_group_name, None)
1980 
1981     def iscontainer(self):
1982         return True
1983 
1984     def containerelements(self):
1985         yield ('command', self.__field_command, None)
1986         yield ('index', self.__field_index, None)
1987         yield ('group_name', self.__field_group_name, None)
1988 
1989 
1990 
1991 
1992 class charset_set_req(BaseProtogenClass):
1993     __fields=['command', 'charset']
1994 
1995     def __init__(self, *args, **kwargs):
1996         dict={}
1997         # What was supplied to this function
1998         dict.update(kwargs)
1999         # Parent constructor
2000         super(charset_set_req,self).__init__(**dict)
2001         if self.__class__ is charset_set_req:
2002             self._update(args,dict)
2003 
2004 
2005     def getfields(self):
2006         return self.__fields
2007 
2008 
2009     def _update(self, args, kwargs):
2010         super(charset_set_req,self)._update(args,kwargs)
2011         keys=kwargs.keys()
2012         for key in keys:
2013             if key in self.__fields:
2014                 setattr(self, key, kwargs[key])
2015                 del kwargs[key]
2016         # Were any unrecognized kwargs passed in?
2017         if __debug__:
2018             self._complainaboutunusedargs(charset_set_req,kwargs)
2019         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2020         # Make all P fields that haven't already been constructed
2021 
2022 
2023     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2024         'Writes this packet to the supplied buffer'
2025         self._bufferstartoffset=buf.getcurrentoffset()
2026         try: self.__field_command
2027         except:
2028             self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CSCS=' })
2029         self.__field_command.writetobuffer(buf)
2030         try: self.__field_charset
2031         except:
2032             self.__field_charset=CSVSTRING(**{ 'terminator': None })
2033         self.__field_charset.writetobuffer(buf)
2034         self._bufferendoffset=buf.getcurrentoffset()
2035         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2036 
2037 
2038     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2039         'Reads this packet from the supplied buffer'
2040         self._bufferstartoffset=buf.getcurrentoffset()
2041         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2042         self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CSCS=' })
2043         self.__field_command.readfrombuffer(buf)
2044         self.__field_charset=CSVSTRING(**{ 'terminator': None })
2045         self.__field_charset.readfrombuffer(buf)
2046         self._bufferendoffset=buf.getcurrentoffset()
2047 
2048 
2049     def __getfield_command(self):
2050         try: self.__field_command
2051         except:
2052             self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CSCS=' })
2053         return self.__field_command.getvalue()
2054 
2055     def __setfield_command(self, value):
2056         if isinstance(value,USTRING):
2057             self.__field_command=value
2058         else:
2059             self.__field_command=USTRING(value,**{ 'terminator': None, 'default': '+CSCS=' })
2060 
2061     def __delfield_command(self): del self.__field_command
2062 
2063     command=property(__getfield_command, __setfield_command, __delfield_command, None)
2064 
2065     def __getfield_charset(self):
2066         try: self.__field_charset
2067         except:
2068             self.__field_charset=CSVSTRING(**{ 'terminator': None })
2069         return self.__field_charset.getvalue()
2070 
2071     def __setfield_charset(self, value):
2072         if isinstance(value,CSVSTRING):
2073             self.__field_charset=value
2074         else:
2075             self.__field_charset=CSVSTRING(value,**{ 'terminator': None })
2076 
2077     def __delfield_charset(self): del self.__field_charset
2078 
2079     charset=property(__getfield_charset, __setfield_charset, __delfield_charset, None)
2080 
2081     def iscontainer(self):
2082         return True
2083 
2084     def containerelements(self):
2085         yield ('command', self.__field_command, None)
2086         yield ('charset', self.__field_charset, None)
2087 
2088 
2089 
2090 
2091 class select_storage_req(BaseProtogenClass):
2092     __fields=['command', 'storage']
2093 
2094     def __init__(self, *args, **kwargs):
2095         dict={}
2096         # What was supplied to this function
2097         dict.update(kwargs)
2098         # Parent constructor
2099         super(select_storage_req,self).__init__(**dict)
2100         if self.__class__ is select_storage_req:
2101             self._update(args,dict)
2102 
2103 
2104     def getfields(self):
2105         return self.__fields
2106 
2107 
2108     def _update(self, args, kwargs):
2109         super(select_storage_req,self)._update(args,kwargs)
2110         keys=kwargs.keys()
2111         for key in keys:
2112             if key in self.__fields:
2113                 setattr(self, key, kwargs[key])
2114                 del kwargs[key]
2115         # Were any unrecognized kwargs passed in?
2116         if __debug__:
2117             self._complainaboutunusedargs(select_storage_req,kwargs)
2118         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2119         # Make all P fields that haven't already been constructed
2120 
2121 
2122     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2123         'Writes this packet to the supplied buffer'
2124         self._bufferstartoffset=buf.getcurrentoffset()
2125         try: self.__field_command
2126         except:
2127             self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CPBS=' })
2128         self.__field_command.writetobuffer(buf)
2129         try: self.__field_storage
2130         except:
2131             self.__field_storage=CSVSTRING(**{ 'terminator': None })
2132         self.__field_storage.writetobuffer(buf)
2133         self._bufferendoffset=buf.getcurrentoffset()
2134         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2135 
2136 
2137     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2138         'Reads this packet from the supplied buffer'
2139         self._bufferstartoffset=buf.getcurrentoffset()
2140         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2141         self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CPBS=' })
2142         self.__field_command.readfrombuffer(buf)
2143         self.__field_storage=CSVSTRING(**{ 'terminator': None })
2144         self.__field_storage.readfrombuffer(buf)
2145         self._bufferendoffset=buf.getcurrentoffset()
2146 
2147 
2148     def __getfield_command(self):
2149         try: self.__field_command
2150         except:
2151             self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CPBS=' })
2152         return self.__field_command.getvalue()
2153 
2154     def __setfield_command(self, value):
2155         if isinstance(value,USTRING):
2156             self.__field_command=value
2157         else:
2158             self.__field_command=USTRING(value,**{ 'terminator': None, 'default': '+CPBS=' })
2159 
2160     def __delfield_command(self): del self.__field_command
2161 
2162     command=property(__getfield_command, __setfield_command, __delfield_command, None)
2163 
2164     def __getfield_storage(self):
2165         try: self.__field_storage
2166         except:
2167             self.__field_storage=CSVSTRING(**{ 'terminator': None })
2168         return self.__field_storage.getvalue()
2169 
2170     def __setfield_storage(self, value):
2171         if isinstance(value,CSVSTRING):
2172             self.__field_storage=value
2173         else:
2174             self.__field_storage=CSVSTRING(value,**{ 'terminator': None })
2175 
2176     def __delfield_storage(self): del self.__field_storage
2177 
2178     storage=property(__getfield_storage, __setfield_storage, __delfield_storage, None)
2179 
2180     def iscontainer(self):
2181         return True
2182 
2183     def containerelements(self):
2184         yield ('command', self.__field_command, None)
2185         yield ('storage', self.__field_storage, None)
2186 
2187 
2188 
2189 
2190 class select_storage_resp(BaseProtogenClass):
2191     __fields=['command', 'storage', 'used_slots_count', 'total_slots_count', 'dunno']
2192 
2193     def __init__(self, *args, **kwargs):
2194         dict={}
2195         # What was supplied to this function
2196         dict.update(kwargs)
2197         # Parent constructor
2198         super(select_storage_resp,self).__init__(**dict)
2199         if self.__class__ is select_storage_resp:
2200             self._update(args,dict)
2201 
2202 
2203     def getfields(self):
2204         return self.__fields
2205 
2206 
2207     def _update(self, args, kwargs):
2208         super(select_storage_resp,self)._update(args,kwargs)
2209         keys=kwargs.keys()
2210         for key in keys:
2211             if key in self.__fields:
2212                 setattr(self, key, kwargs[key])
2213                 del kwargs[key]
2214         # Were any unrecognized kwargs passed in?
2215         if __debug__:
2216             self._complainaboutunusedargs(select_storage_resp,kwargs)
2217         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2218         # Make all P fields that haven't already been constructed
2219 
2220 
2221     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2222         'Writes this packet to the supplied buffer'
2223         self._bufferstartoffset=buf.getcurrentoffset()
2224         self.__field_command.writetobuffer(buf)
2225         self.__field_storage.writetobuffer(buf)
2226         self.__field_used_slots_count.writetobuffer(buf)
2227         self.__field_total_slots_count.writetobuffer(buf)
2228         self.__field_dunno.writetobuffer(buf)
2229         self._bufferendoffset=buf.getcurrentoffset()
2230         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2231 
2232 
2233     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2234         'Reads this packet from the supplied buffer'
2235         self._bufferstartoffset=buf.getcurrentoffset()
2236         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2237         self.__field_command=USTRING(**{ 'terminator': ord(' '), 'constant': '+CPBS:' })
2238         self.__field_command.readfrombuffer(buf)
2239         self.__field_storage=CSVSTRING()
2240         self.__field_storage.readfrombuffer(buf)
2241         self.__field_used_slots_count=CSVINT()
2242         self.__field_used_slots_count.readfrombuffer(buf)
2243         self.__field_total_slots_count=CSVINT()
2244         self.__field_total_slots_count.readfrombuffer(buf)
2245         self.__field_dunno=CSVINT(**{ 'terminator': None })
2246         self.__field_dunno.readfrombuffer(buf)
2247         self._bufferendoffset=buf.getcurrentoffset()
2248 
2249 
2250     def __getfield_command(self):
2251         return self.__field_command.getvalue()
2252 
2253     def __setfield_command(self, value):
2254         if isinstance(value,USTRING):
2255             self.__field_command=value
2256         else:
2257             self.__field_command=USTRING(value,**{ 'terminator': ord(' '), 'constant': '+CPBS:' })
2258 
2259     def __delfield_command(self): del self.__field_command
2260 
2261     command=property(__getfield_command, __setfield_command, __delfield_command, None)
2262 
2263     def __getfield_storage(self):
2264         return self.__field_storage.getvalue()
2265 
2266     def __setfield_storage(self, value):
2267         if isinstance(value,CSVSTRING):
2268             self.__field_storage=value
2269         else:
2270             self.__field_storage=CSVSTRING(value,)
2271 
2272     def __delfield_storage(self): del self.__field_storage
2273 
2274     storage=property(__getfield_storage, __setfield_storage, __delfield_storage, None)
2275 
2276     def __getfield_used_slots_count(self):
2277         return self.__field_used_slots_count.getvalue()
2278 
2279     def __setfield_used_slots_count(self, value):
2280         if isinstance(value,CSVINT):
2281             self.__field_used_slots_count=value
2282         else:
2283             self.__field_used_slots_count=CSVINT(value,)
2284 
2285     def __delfield_used_slots_count(self): del self.__field_used_slots_count
2286 
2287     used_slots_count=property(__getfield_used_slots_count, __setfield_used_slots_count, __delfield_used_slots_count, None)
2288 
2289     def __getfield_total_slots_count(self):
2290         return self.__field_total_slots_count.getvalue()
2291 
2292     def __setfield_total_slots_count(self, value):
2293         if isinstance(value,CSVINT):
2294             self.__field_total_slots_count=value
2295         else:
2296             self.__field_total_slots_count=CSVINT(value,)
2297 
2298     def __delfield_total_slots_count(self): del self.__field_total_slots_count
2299 
2300     total_slots_count=property(__getfield_total_slots_count, __setfield_total_slots_count, __delfield_total_slots_count, None)
2301 
2302     def __getfield_dunno(self):
2303         return self.__field_dunno.getvalue()
2304 
2305     def __setfield_dunno(self, value):
2306         if isinstance(value,CSVINT):
2307             self.__field_dunno=value
2308         else:
2309             self.__field_dunno=CSVINT(value,**{ 'terminator': None })
2310 
2311     def __delfield_dunno(self): del self.__field_dunno
2312 
2313     dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, None)
2314 
2315     def iscontainer(self):
2316         return True
2317 
2318     def containerelements(self):
2319         yield ('command', self.__field_command, None)
2320         yield ('storage', self.__field_storage, None)
2321         yield ('used_slots_count', self.__field_used_slots_count, None)
2322         yield ('total_slots_count', self.__field_total_slots_count, None)
2323         yield ('dunno', self.__field_dunno, None)
2324 
2325 
2326 
2327 
2328 class read_phonebook_req(BaseProtogenClass):
2329     __fields=['command', 'start_index', 'end_index']
2330 
2331     def __init__(self, *args, **kwargs):
2332         dict={}
2333         # What was supplied to this function
2334         dict.update(kwargs)
2335         # Parent constructor
2336         super(read_phonebook_req,self).__init__(**dict)
2337         if self.__class__ is read_phonebook_req:
2338             self._update(args,dict)
2339 
2340 
2341     def getfields(self):
2342         return self.__fields
2343 
2344 
2345     def _update(self, args, kwargs):
2346         super(read_phonebook_req,self)._update(args,kwargs)
2347         keys=kwargs.keys()
2348         for key in keys:
2349             if key in self.__fields:
2350                 setattr(self, key, kwargs[key])
2351                 del kwargs[key]
2352         # Were any unrecognized kwargs passed in?
2353         if __debug__:
2354             self._complainaboutunusedargs(read_phonebook_req,kwargs)
2355         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2356         # Make all P fields that haven't already been constructed
2357 
2358 
2359     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2360         'Writes this packet to the supplied buffer'
2361         self._bufferstartoffset=buf.getcurrentoffset()
2362         try: self.__field_command
2363         except:
2364             self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CPBR=' })
2365         self.__field_command.writetobuffer(buf)
2366         try: self.__field_start_index
2367         except:
2368             self.__field_start_index=CSVINT()
2369         self.__field_start_index.writetobuffer(buf)
2370         try: self.__field_end_index
2371         except:
2372             self.__field_end_index=CSVINT(**{ 'terminator': None })
2373         self.__field_end_index.writetobuffer(buf)
2374         self._bufferendoffset=buf.getcurrentoffset()
2375         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2376 
2377 
2378     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2379         'Reads this packet from the supplied buffer'
2380         self._bufferstartoffset=buf.getcurrentoffset()
2381         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2382         self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CPBR=' })
2383         self.__field_command.readfrombuffer(buf)
2384         self.__field_start_index=CSVINT()
2385         self.__field_start_index.readfrombuffer(buf)
2386         self.__field_end_index=CSVINT(**{ 'terminator': None })
2387         self.__field_end_index.readfrombuffer(buf)
2388         self._bufferendoffset=buf.getcurrentoffset()
2389 
2390 
2391     def __getfield_command(self):
2392         try: self.__field_command
2393         except:
2394             self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CPBR=' })
2395         return self.__field_command.getvalue()
2396 
2397     def __setfield_command(self, value):
2398         if isinstance(value,USTRING):
2399             self.__field_command=value
2400         else:
2401             self.__field_command=USTRING(value,**{ 'terminator': None, 'default': '+CPBR=' })
2402 
2403     def __delfield_command(self): del self.__field_command
2404 
2405     command=property(__getfield_command, __setfield_command, __delfield_command, None)
2406 
2407     def __getfield_start_index(self):
2408         try: self.__field_start_index
2409         except:
2410             self.__field_start_index=CSVINT()
2411         return self.__field_start_index.getvalue()
2412 
2413     def __setfield_start_index(self, value):
2414         if isinstance(value,CSVINT):
2415             self.__field_start_index=value
2416         else:
2417             self.__field_start_index=CSVINT(value,)
2418 
2419     def __delfield_start_index(self): del self.__field_start_index
2420 
2421     start_index=property(__getfield_start_index, __setfield_start_index, __delfield_start_index, None)
2422 
2423     def __getfield_end_index(self):
2424         try: self.__field_end_index
2425         except:
2426             self.__field_end_index=CSVINT(**{ 'terminator': None })
2427         return self.__field_end_index.getvalue()
2428 
2429     def __setfield_end_index(self, value):
2430         if isinstance(value,CSVINT):
2431             self.__field_end_index=value
2432         else:
2433             self.__field_end_index=CSVINT(value,**{ 'terminator': None })
2434 
2435     def __delfield_end_index(self): del self.__field_end_index
2436 
2437     end_index=property(__getfield_end_index, __setfield_end_index, __delfield_end_index, None)
2438 
2439     def iscontainer(self):
2440         return True
2441 
2442     def containerelements(self):
2443         yield ('command', self.__field_command, None)
2444         yield ('start_index', self.__field_start_index, None)
2445         yield ('end_index', self.__field_end_index, None)
2446 
2447 
2448 
2449 
2450 class read_phonebook_resp(BaseProtogenClass):
2451     __fields=['sim', 'command', 'index', 'group', 'mobile', 'mobile_type', 'home', 'home_type', 'office', 'office_type', 'name', 'email', 'memo']
2452 
2453     def __init__(self, *args, **kwargs):
2454         dict={}
2455         # What was supplied to this function
2456         dict.update(kwargs)
2457         # Parent constructor
2458         super(read_phonebook_resp,self).__init__(**dict)
2459         if self.__class__ is read_phonebook_resp:
2460             self._update(args,dict)
2461 
2462 
2463     def getfields(self):
2464         return self.__fields
2465 
2466 
2467     def _update(self, args, kwargs):
2468         super(read_phonebook_resp,self)._update(args,kwargs)
2469         keys=kwargs.keys()
2470         for key in keys:
2471             if key in self.__fields:
2472                 setattr(self, key, kwargs[key])
2473                 del kwargs[key]
2474         # Were any unrecognized kwargs passed in?
2475         if __debug__:
2476             self._complainaboutunusedargs(read_phonebook_resp,kwargs)
2477         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2478         # Make all P fields that haven't already been constructed
2479         try: self.__field_sim
2480         except:
2481             self.__field_sim=BOOL(**{ 'default': False })
2482 
2483 
2484     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2485         'Writes this packet to the supplied buffer'
2486         self._bufferstartoffset=buf.getcurrentoffset()
2487         self.__field_command.writetobuffer(buf)
2488         self.__field_index.writetobuffer(buf)
2489         self.__field_group.writetobuffer(buf)
2490         self.__field_mobile.writetobuffer(buf)
2491         self.__field_mobile_type.writetobuffer(buf)
2492         self.__field_home.writetobuffer(buf)
2493         self.__field_home_type.writetobuffer(buf)
2494         self.__field_office.writetobuffer(buf)
2495         self.__field_office_type.writetobuffer(buf)
2496         self.__field_name.writetobuffer(buf)
2497         self.__field_email.writetobuffer(buf)
2498         self.__field_memo.writetobuffer(buf)
2499         self._bufferendoffset=buf.getcurrentoffset()
2500         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2501 
2502 
2503     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2504         'Reads this packet from the supplied buffer'
2505         self._bufferstartoffset=buf.getcurrentoffset()
2506         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2507         self.__field_command=USTRING(**{ 'terminator': ord(' '), 'constant': '+CPBR:' })
2508         self.__field_command.readfrombuffer(buf)
2509         self.__field_index=CSVINT()
2510         self.__field_index.readfrombuffer(buf)
2511         self.__field_group=CSVINT()
2512         self.__field_group.readfrombuffer(buf)
2513         self.__field_mobile=CSVSTRING()
2514         self.__field_mobile.readfrombuffer(buf)
2515         self.__field_mobile_type=CSVINT()
2516         self.__field_mobile_type.readfrombuffer(buf)
2517         self.__field_home=CSVSTRING()
2518         self.__field_home.readfrombuffer(buf)
2519         self.__field_home_type=CSVINT()
2520         self.__field_home_type.readfrombuffer(buf)
2521         self.__field_office=CSVSTRING()
2522         self.__field_office.readfrombuffer(buf)
2523         self.__field_office_type=CSVINT()
2524         self.__field_office_type.readfrombuffer(buf)
2525         self.__field_name=CSVSTRING()
2526         self.__field_name.readfrombuffer(buf)
2527         self.__field_email=CSVSTRING()
2528         self.__field_email.readfrombuffer(buf)
2529         self.__field_memo=CSVSTRING()
2530         self.__field_memo.readfrombuffer(buf)
2531         self._bufferendoffset=buf.getcurrentoffset()
2532 
2533 
2534     def __getfield_sim(self):
2535         try: self.__field_sim
2536         except:
2537             self.__field_sim=BOOL(**{ 'default': False })
2538         return self.__field_sim.getvalue()
2539 
2540     def __setfield_sim(self, value):
2541         if isinstance(value,BOOL):
2542             self.__field_sim=value
2543         else:
2544             self.__field_sim=BOOL(value,**{ 'default': False })
2545 
2546     def __delfield_sim(self): del self.__field_sim
2547 
2548     sim=property(__getfield_sim, __setfield_sim, __delfield_sim, None)
2549 
2550     def __getfield_command(self):
2551         return self.__field_command.getvalue()
2552 
2553     def __setfield_command(self, value):
2554         if isinstance(value,USTRING):
2555             self.__field_command=value
2556         else:
2557             self.__field_command=USTRING(value,**{ 'terminator': ord(' '), 'constant': '+CPBR:' })
2558 
2559     def __delfield_command(self): del self.__field_command
2560 
2561     command=property(__getfield_command, __setfield_command, __delfield_command, None)
2562 
2563     def __getfield_index(self):
2564         return self.__field_index.getvalue()
2565 
2566     def __setfield_index(self, value):
2567         if isinstance(value,CSVINT):
2568             self.__field_index=value
2569         else:
2570             self.__field_index=CSVINT(value,)
2571 
2572     def __delfield_index(self): del self.__field_index
2573 
2574     index=property(__getfield_index, __setfield_index, __delfield_index, None)
2575 
2576     def __getfield_group(self):
2577         return self.__field_group.getvalue()
2578 
2579     def __setfield_group(self, value):
2580         if isinstance(value,CSVINT):
2581             self.__field_group=value
2582         else:
2583             self.__field_group=CSVINT(value,)
2584 
2585     def __delfield_group(self): del self.__field_group
2586 
2587     group=property(__getfield_group, __setfield_group, __delfield_group, None)
2588 
2589     def __getfield_mobile(self):
2590         return self.__field_mobile.getvalue()
2591 
2592     def __setfield_mobile(self, value):
2593         if isinstance(value,CSVSTRING):
2594             self.__field_mobile=value
2595         else:
2596             self.__field_mobile=CSVSTRING(value,)
2597 
2598     def __delfield_mobile(self): del self.__field_mobile
2599 
2600     mobile=property(__getfield_mobile, __setfield_mobile, __delfield_mobile, None)
2601 
2602     def __getfield_mobile_type(self):
2603         return self.__field_mobile_type.getvalue()
2604 
2605     def __setfield_mobile_type(self, value):
2606         if isinstance(value,CSVINT):
2607             self.__field_mobile_type=value
2608         else:
2609             self.__field_mobile_type=CSVINT(value,)
2610 
2611     def __delfield_mobile_type(self): del self.__field_mobile_type
2612 
2613     mobile_type=property(__getfield_mobile_type, __setfield_mobile_type, __delfield_mobile_type, None)
2614 
2615     def __getfield_home(self):
2616         return self.__field_home.getvalue()
2617 
2618     def __setfield_home(self, value):
2619         if isinstance(value,CSVSTRING):
2620             self.__field_home=value
2621         else:
2622             self.__field_home=CSVSTRING(value,)
2623 
2624     def __delfield_home(self): del self.__field_home
2625 
2626     home=property(__getfield_home, __setfield_home, __delfield_home, None)
2627 
2628     def __getfield_home_type(self):
2629         return self.__field_home_type.getvalue()
2630 
2631     def __setfield_home_type(self, value):
2632         if isinstance(value,CSVINT):
2633             self.__field_home_type=value
2634         else:
2635             self.__field_home_type=CSVINT(value,)
2636 
2637     def __delfield_home_type(self): del self.__field_home_type
2638 
2639     home_type=property(__getfield_home_type, __setfield_home_type, __delfield_home_type, None)
2640 
2641     def __getfield_office(self):
2642         return self.__field_office.getvalue()
2643 
2644     def __setfield_office(self, value):
2645         if isinstance(value,CSVSTRING):
2646             self.__field_office=value
2647         else:
2648             self.__field_office=CSVSTRING(value,)
2649 
2650     def __delfield_office(self): del self.__field_office
2651 
2652     office=property(__getfield_office, __setfield_office, __delfield_office, None)
2653 
2654     def __getfield_office_type(self):
2655         return self.__field_office_type.getvalue()
2656 
2657     def __setfield_office_type(self, value):
2658         if isinstance(value,CSVINT):
2659             self.__field_office_type=value
2660         else:
2661             self.__field_office_type=CSVINT(value,)
2662 
2663     def __delfield_office_type(self): del self.__field_office_type
2664 
2665     office_type=property(__getfield_office_type, __setfield_office_type, __delfield_office_type, None)
2666 
2667     def __getfield_name(self):
2668         return self.__field_name.getvalue()
2669 
2670     def __setfield_name(self, value):
2671         if isinstance(value,CSVSTRING):
2672             self.__field_name=value
2673         else:
2674             self.__field_name=CSVSTRING(value,)
2675 
2676     def __delfield_name(self): del self.__field_name
2677 
2678     name=property(__getfield_name, __setfield_name, __delfield_name, None)
2679 
2680     def __getfield_email(self):
2681         return self.__field_email.getvalue()
2682 
2683     def __setfield_email(self, value):
2684         if isinstance(value,CSVSTRING):
2685             self.__field_email=value
2686         else:
2687             self.__field_email=CSVSTRING(value,)
2688 
2689     def __delfield_email(self): del self.__field_email
2690 
2691     email=property(__getfield_email, __setfield_email, __delfield_email, None)
2692 
2693     def __getfield_memo(self):
2694         return self.__field_memo.getvalue()
2695 
2696     def __setfield_memo(self, value):
2697         if isinstance(value,CSVSTRING):
2698             self.__field_memo=value
2699         else:
2700             self.__field_memo=CSVSTRING(value,)
2701 
2702     def __delfield_memo(self): del self.__field_memo
2703 
2704     memo=property(__getfield_memo, __setfield_memo, __delfield_memo, None)
2705 
2706     def iscontainer(self):
2707         return True
2708 
2709     def containerelements(self):
2710         yield ('sim', self.__field_sim, None)
2711         yield ('command', self.__field_command, None)
2712         yield ('index', self.__field_index, None)
2713         yield ('group', self.__field_group, None)
2714         yield ('mobile', self.__field_mobile, None)
2715         yield ('mobile_type', self.__field_mobile_type, None)
2716         yield ('home', self.__field_home, None)
2717         yield ('home_type', self.__field_home_type, None)
2718         yield ('office', self.__field_office, None)
2719         yield ('office_type', self.__field_office_type, None)
2720         yield ('name', self.__field_name, None)
2721         yield ('email', self.__field_email, None)
2722         yield ('memo', self.__field_memo, None)
2723 
2724 
2725 
2726 
2727 class read_sim_phonebook_resp(BaseProtogenClass):
2728     __fields=['command', 'index', 'group', 'mobile', 'mobile_type', 'name', 'home', 'office', 'email', 'memo', 'sim']
2729 
2730     def __init__(self, *args, **kwargs):
2731         dict={}
2732         # What was supplied to this function
2733         dict.update(kwargs)
2734         # Parent constructor
2735         super(read_sim_phonebook_resp,self).__init__(**dict)
2736         if self.__class__ is read_sim_phonebook_resp:
2737             self._update(args,dict)
2738 
2739 
2740     def getfields(self):
2741         return self.__fields
2742 
2743 
2744     def _update(self, args, kwargs):
2745         super(read_sim_phonebook_resp,self)._update(args,kwargs)
2746         keys=kwargs.keys()
2747         for key in keys:
2748             if key in self.__fields:
2749                 setattr(self, key, kwargs[key])
2750                 del kwargs[key]
2751         # Were any unrecognized kwargs passed in?
2752         if __debug__:
2753             self._complainaboutunusedargs(read_sim_phonebook_resp,kwargs)
2754         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2755         # Make all P fields that haven't already been constructed
2756         try: self.__field_home
2757         except:
2758             self.__field_home=USTRING(**{ 'terminator': None, 'default': '' })
2759         try: self.__field_office
2760         except:
2761             self.__field_office=USTRING(**{ 'terminator': None, 'default': '' })
2762         try: self.__field_email
2763         except:
2764             self.__field_email=USTRING(**{ 'terminator': None, 'default': '' })
2765         try: self.__field_memo
2766         except:
2767             self.__field_memo=USTRING(**{ 'terminator': None, 'default': '' })
2768         try: self.__field_sim
2769         except:
2770             self.__field_sim=BOOL(**{ 'default': True })
2771 
2772 
2773     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2774         'Writes this packet to the supplied buffer'
2775         self._bufferstartoffset=buf.getcurrentoffset()
2776         self.__field_command.writetobuffer(buf)
2777         self.__field_index.writetobuffer(buf)
2778         self.__field_group.writetobuffer(buf)
2779         self.__field_mobile.writetobuffer(buf)
2780         self.__field_mobile_type.writetobuffer(buf)
2781         self.__field_name.writetobuffer(buf)
2782         self._bufferendoffset=buf.getcurrentoffset()
2783         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2784 
2785 
2786     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2787         'Reads this packet from the supplied buffer'
2788         self._bufferstartoffset=buf.getcurrentoffset()
2789         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2790         self.__field_command=USTRING(**{ 'terminator': ord(' '), 'constant': '+CPBR:' })
2791         self.__field_command.readfrombuffer(buf)
2792         self.__field_index=CSVINT()
2793         self.__field_index.readfrombuffer(buf)
2794         self.__field_group=CSVINT()
2795         self.__field_group.readfrombuffer(buf)
2796         self.__field_mobile=CSVSTRING()
2797         self.__field_mobile.readfrombuffer(buf)
2798         self.__field_mobile_type=CSVINT()
2799         self.__field_mobile_type.readfrombuffer(buf)
2800         self.__field_name=CSVSTRING()
2801         self.__field_name.readfrombuffer(buf)
2802         self._bufferendoffset=buf.getcurrentoffset()
2803 
2804 
2805     def __getfield_command(self):
2806         return self.__field_command.getvalue()
2807 
2808     def __setfield_command(self, value):
2809         if isinstance(value,USTRING):
2810             self.__field_command=value
2811         else:
2812             self.__field_command=USTRING(value,**{ 'terminator': ord(' '), 'constant': '+CPBR:' })
2813 
2814     def __delfield_command(self): del self.__field_command
2815 
2816     command=property(__getfield_command, __setfield_command, __delfield_command, None)
2817 
2818     def __getfield_index(self):
2819         return self.__field_index.getvalue()
2820 
2821     def __setfield_index(self, value):
2822         if isinstance(value,CSVINT):
2823             self.__field_index=value
2824         else:
2825             self.__field_index=CSVINT(value,)
2826 
2827     def __delfield_index(self): del self.__field_index
2828 
2829     index=property(__getfield_index, __setfield_index, __delfield_index, None)
2830 
2831     def __getfield_group(self):
2832         return self.__field_group.getvalue()
2833 
2834     def __setfield_group(self, value):
2835         if isinstance(value,CSVINT):
2836             self.__field_group=value
2837         else:
2838             self.__field_group=CSVINT(value,)
2839 
2840     def __delfield_group(self): del self.__field_group
2841 
2842     group=property(__getfield_group, __setfield_group, __delfield_group, None)
2843 
2844     def __getfield_mobile(self):
2845         return self.__field_mobile.getvalue()
2846 
2847     def __setfield_mobile(self, value):
2848         if isinstance(value,CSVSTRING):
2849             self.__field_mobile=value
2850         else:
2851             self.__field_mobile=CSVSTRING(value,)
2852 
2853     def __delfield_mobile(self): del self.__field_mobile
2854 
2855     mobile=property(__getfield_mobile, __setfield_mobile, __delfield_mobile, None)
2856 
2857     def __getfield_mobile_type(self):
2858         return self.__field_mobile_type.getvalue()
2859 
2860     def __setfield_mobile_type(self, value):
2861         if isinstance(value,CSVINT):
2862             self.__field_mobile_type=value
2863         else:
2864             self.__field_mobile_type=CSVINT(value,)
2865 
2866     def __delfield_mobile_type(self): del self.__field_mobile_type
2867 
2868     mobile_type=property(__getfield_mobile_type, __setfield_mobile_type, __delfield_mobile_type, None)
2869 
2870     def __getfield_name(self):
2871         return self.__field_name.getvalue()
2872 
2873     def __setfield_name(self, value):
2874         if isinstance(value,CSVSTRING):
2875             self.__field_name=value
2876         else:
2877             self.__field_name=CSVSTRING(value,)
2878 
2879     def __delfield_name(self): del self.__field_name
2880 
2881     name=property(__getfield_name, __setfield_name, __delfield_name, None)
2882 
2883     def __getfield_home(self):
2884         try: self.__field_home
2885         except:
2886             self.__field_home=USTRING(**{ 'terminator': None, 'default': '' })
2887         return self.__field_home.getvalue()
2888 
2889     def __setfield_home(self, value):
2890         if isinstance(value,USTRING):
2891             self.__field_home=value
2892         else:
2893             self.__field_home=USTRING(value,**{ 'terminator': None, 'default': '' })
2894 
2895     def __delfield_home(self): del self.__field_home
2896 
2897     home=property(__getfield_home, __setfield_home, __delfield_home, None)
2898 
2899     def __getfield_office(self):
2900         try: self.__field_office
2901         except:
2902             self.__field_office=USTRING(**{ 'terminator': None, 'default': '' })
2903         return self.__field_office.getvalue()
2904 
2905     def __setfield_office(self, value):
2906         if isinstance(value,USTRING):
2907             self.__field_office=value
2908         else:
2909             self.__field_office=USTRING(value,**{ 'terminator': None, 'default': '' })
2910 
2911     def __delfield_office(self): del self.__field_office
2912 
2913     office=property(__getfield_office, __setfield_office, __delfield_office, None)
2914 
2915     def __getfield_email(self):
2916         try: self.__field_email
2917         except:
2918             self.__field_email=USTRING(**{ 'terminator': None, 'default': '' })
2919         return self.__field_email.getvalue()
2920 
2921     def __setfield_email(self, value):
2922         if isinstance(value,USTRING):
2923             self.__field_email=value
2924         else:
2925             self.__field_email=USTRING(value,**{ 'terminator': None, 'default': '' })
2926 
2927     def __delfield_email(self): del self.__field_email
2928 
2929     email=property(__getfield_email, __setfield_email, __delfield_email, None)
2930 
2931     def __getfield_memo(self):
2932         try: self.__field_memo
2933         except:
2934             self.__field_memo=USTRING(**{ 'terminator': None, 'default': '' })
2935         return self.__field_memo.getvalue()
2936 
2937     def __setfield_memo(self, value):
2938         if isinstance(value,USTRING):
2939             self.__field_memo=value
2940         else:
2941             self.__field_memo=USTRING(value,**{ 'terminator': None, 'default': '' })
2942 
2943     def __delfield_memo(self): del self.__field_memo
2944 
2945     memo=property(__getfield_memo, __setfield_memo, __delfield_memo, None)
2946 
2947     def __getfield_sim(self):
2948         try: self.__field_sim
2949         except:
2950             self.__field_sim=BOOL(**{ 'default': True })
2951         return self.__field_sim.getvalue()
2952 
2953     def __setfield_sim(self, value):
2954         if isinstance(value,BOOL):
2955             self.__field_sim=value
2956         else:
2957             self.__field_sim=BOOL(value,**{ 'default': True })
2958 
2959     def __delfield_sim(self): del self.__field_sim
2960 
2961     sim=property(__getfield_sim, __setfield_sim, __delfield_sim, None)
2962 
2963     def iscontainer(self):
2964         return True
2965 
2966     def containerelements(self):
2967         yield ('command', self.__field_command, None)
2968         yield ('index', self.__field_index, None)
2969         yield ('group', self.__field_group, None)
2970         yield ('mobile', self.__field_mobile, None)
2971         yield ('mobile_type', self.__field_mobile_type, None)
2972         yield ('name', self.__field_name, None)
2973         yield ('home', self.__field_home, None)
2974         yield ('office', self.__field_office, None)
2975         yield ('email', self.__field_email, None)
2976         yield ('memo', self.__field_memo, None)
2977         yield ('sim', self.__field_sim, None)
2978 
2979 
2980 
2981 
2982 class del_phonebook_req(BaseProtogenClass):
2983     __fields=['command', 'index']
2984 
2985     def __init__(self, *args, **kwargs):
2986         dict={}
2987         # What was supplied to this function
2988         dict.update(kwargs)
2989         # Parent constructor
2990         super(del_phonebook_req,self).__init__(**dict)
2991         if self.__class__ is del_phonebook_req:
2992             self._update(args,dict)
2993 
2994 
2995     def getfields(self):
2996         return self.__fields
2997 
2998 
2999     def _update(self, args, kwargs):
3000         super(del_phonebook_req,self)._update(args,kwargs)
3001         keys=kwargs.keys()
3002         for key in keys:
3003             if key in self.__fields:
3004                 setattr(self, key, kwargs[key])
3005                 del kwargs[key]
3006         # Were any unrecognized kwargs passed in?
3007         if __debug__:
3008             self._complainaboutunusedargs(del_phonebook_req,kwargs)
3009         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3010         # Make all P fields that haven't already been constructed
3011 
3012 
3013     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3014         'Writes this packet to the supplied buffer'
3015         self._bufferstartoffset=buf.getcurrentoffset()
3016         try: self.__field_command
3017         except:
3018             self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CPBW=' })
3019         self.__field_command.writetobuffer(buf)
3020         try: self.__field_index
3021         except:
3022             self.__field_index=CSVINT(**{ 'terminator': None })
3023         self.__field_index.writetobuffer(buf)
3024         self._bufferendoffset=buf.getcurrentoffset()
3025         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3026 
3027 
3028     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3029         'Reads this packet from the supplied buffer'
3030         self._bufferstartoffset=buf.getcurrentoffset()
3031         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3032         self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CPBW=' })
3033         self.__field_command.readfrombuffer(buf)
3034         self.__field_index=CSVINT(**{ 'terminator': None })
3035         self.__field_index.readfrombuffer(buf)
3036         self._bufferendoffset=buf.getcurrentoffset()
3037 
3038 
3039     def __getfield_command(self):
3040         try: self.__field_command
3041         except:
3042             self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CPBW=' })
3043         return self.__field_command.getvalue()
3044 
3045     def __setfield_command(self, value):
3046         if isinstance(value,USTRING):
3047             self.__field_command=value
3048         else:
3049             self.__field_command=USTRING(value,**{ 'terminator': None, 'default': '+CPBW=' })
3050 
3051     def __delfield_command(self): del self.__field_command
3052 
3053     command=property(__getfield_command, __setfield_command, __delfield_command, None)
3054 
3055     def __getfield_index(self):
3056         try: self.__field_index
3057         except:
3058             self.__field_index=CSVINT(**{ 'terminator': None })
3059         return self.__field_index.getvalue()
3060 
3061     def __setfield_index(self, value):
3062         if isinstance(value,CSVINT):
3063             self.__field_index=value
3064         else:
3065             self.__field_index=CSVINT(value,**{ 'terminator': None })
3066 
3067     def __delfield_index(self): del self.__field_index
3068 
3069     index=property(__getfield_index, __setfield_index, __delfield_index, None)
3070 
3071     def iscontainer(self):
3072         return True
3073 
3074     def containerelements(self):
3075         yield ('command', self.__field_command, None)
3076         yield ('index', self.__field_index, None)
3077 
3078 
3079 
3080 
3081 class update_phonebook_resp(BaseProtogenClass):
3082     __fields=['command', 'index']
3083 
3084     def __init__(self, *args, **kwargs):
3085         dict={}
3086         # What was supplied to this function
3087         dict.update(kwargs)
3088         # Parent constructor
3089         super(update_phonebook_resp,self).__init__(**dict)
3090         if self.__class__ is update_phonebook_resp:
3091             self._update(args,dict)
3092 
3093 
3094     def getfields(self):
3095         return self.__fields
3096 
3097 
3098     def _update(self, args, kwargs):
3099         super(update_phonebook_resp,self)._update(args,kwargs)
3100         keys=kwargs.keys()
3101         for key in keys:
3102             if key in self.__fields:
3103                 setattr(self, key, kwargs[key])
3104                 del kwargs[key]
3105         # Were any unrecognized kwargs passed in?
3106         if __debug__:
3107             self._complainaboutunusedargs(update_phonebook_resp,kwargs)
3108         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3109         # Make all P fields that haven't already been constructed
3110 
3111 
3112     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3113         'Writes this packet to the supplied buffer'
3114         self._bufferstartoffset=buf.getcurrentoffset()
3115         self.__field_command.writetobuffer(buf)
3116         self.__field_index.writetobuffer(buf)
3117         self._bufferendoffset=buf.getcurrentoffset()
3118         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3119 
3120 
3121     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3122         'Reads this packet from the supplied buffer'
3123         self._bufferstartoffset=buf.getcurrentoffset()
3124         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3125         self.__field_command=USTRING(**{ 'terminator': ord(' '), 'constant': '+CPBW:' })
3126         self.__field_command.readfrombuffer(buf)
3127         self.__field_index=CSVINT(**{ 'terminator': None })
3128         self.__field_index.readfrombuffer(buf)
3129         self._bufferendoffset=buf.getcurrentoffset()
3130 
3131 
3132     def __getfield_command(self):
3133         return self.__field_command.getvalue()
3134 
3135     def __setfield_command(self, value):
3136         if isinstance(value,USTRING):
3137             self.__field_command=value
3138         else:
3139             self.__field_command=USTRING(value,**{ 'terminator': ord(' '), 'constant': '+CPBW:' })
3140 
3141     def __delfield_command(self): del self.__field_command
3142 
3143     command=property(__getfield_command, __setfield_command, __delfield_command, None)
3144 
3145     def __getfield_index(self):
3146         return self.__field_index.getvalue()
3147 
3148     def __setfield_index(self, value):
3149         if isinstance(value,CSVINT):
3150             self.__field_index=value
3151         else:
3152             self.__field_index=CSVINT(value,**{ 'terminator': None })
3153 
3154     def __delfield_index(self): del self.__field_index
3155 
3156     index=property(__getfield_index, __setfield_index, __delfield_index, None)
3157 
3158     def iscontainer(self):
3159         return True
3160 
3161     def containerelements(self):
3162         yield ('command', self.__field_command, None)
3163         yield ('index', self.__field_index, None)
3164 
3165 
3166 
3167 
3168 class write_phonebook_req(BaseProtogenClass):
3169     __fields=['command', 'group', 'mobile', 'mobile_type', 'home', 'home_type', 'office', 'office_type', 'name', 'email', 'memo']
3170 
3171     def __init__(self, *args, **kwargs):
3172         dict={}
3173         # What was supplied to this function
3174         dict.update(kwargs)
3175         # Parent constructor
3176         super(write_phonebook_req,self).__init__(**dict)
3177         if self.__class__ is write_phonebook_req:
3178             self._update(args,dict)
3179 
3180 
3181     def getfields(self):
3182         return self.__fields
3183 
3184 
3185     def _update(self, args, kwargs):
3186         super(write_phonebook_req,self)._update(args,kwargs)
3187         keys=kwargs.keys()
3188         for key in keys:
3189             if key in self.__fields:
3190                 setattr(self, key, kwargs[key])
3191                 del kwargs[key]
3192         # Were any unrecognized kwargs passed in?
3193         if __debug__:
3194             self._complainaboutunusedargs(write_phonebook_req,kwargs)
3195         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3196         # Make all P fields that haven't already been constructed
3197 
3198 
3199     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3200         'Writes this packet to the supplied buffer'
3201         self._bufferstartoffset=buf.getcurrentoffset()
3202         try: self.__field_command
3203         except:
3204             self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CPBW=,' })
3205         self.__field_command.writetobuffer(buf)
3206         try: self.__field_group
3207         except:
3208             self.__field_group=CSVINT()
3209         self.__field_group.writetobuffer(buf)
3210         try: self.__field_mobile
3211         except:
3212             self.__field_mobile=CSVSTRING(**{ 'default': '',                  'maxsizeinbytes': PB_NUMBER_LEN,                  'raiseontruncate': False })
3213         self.__field_mobile.writetobuffer(buf)
3214         try: self.__field_mobile_type
3215         except:
3216             self.__field_mobile_type=CSVINT(**{ 'default': 255 })
3217         self.__field_mobile_type.writetobuffer(buf)
3218         try: self.__field_home
3219         except:
3220             self.__field_home=CSVSTRING(**{ 'default': '',                  'maxsizeinbytes': PB_NUMBER_LEN,                  'raiseontruncate': False })
3221         self.__field_home.writetobuffer(buf)
3222         try: self.__field_home_type
3223         except:
3224             self.__field_home_type=CSVINT(**{ 'default': 255 })
3225         self.__field_home_type.writetobuffer(buf)
3226         try: self.__field_office
3227         except:
3228             self.__field_office=CSVSTRING(**{ 'default': '',                  'maxsizeinbytes': PB_NUMBER_LEN,                  'raiseontruncate': False })
3229         self.__field_office.writetobuffer(buf)
3230         try: self.__field_office_type
3231         except:
3232             self.__field_office_type=CSVINT(**{ 'default': 255 })
3233         self.__field_office_type.writetobuffer(buf)
3234         try: self.__field_name
3235         except:
3236             self.__field_name=CSVSTRING(**{ 'maxsizeinbytes': PB_NAME_LEN,                  'raiseontruncate': False })
3237         self.__field_name.writetobuffer(buf)
3238         try: self.__field_email
3239         except:
3240             self.__field_email=CSVSTRING(**{ 'default': '',                  'maxsizeinbytes': PB_EMAIL_LEN,                  'raiseontruncate': False })
3241         self.__field_email.writetobuffer(buf)
3242         try: self.__field_memo
3243         except:
3244             self.__field_memo=CSVSTRING(**{ 'terminator': None, 'default': '',                  'maxsizeinbytes': PB_MEMO_LEN,                  'raiseontruncate': False })
3245         self.__field_memo.writetobuffer(buf)
3246         self._bufferendoffset=buf.getcurrentoffset()
3247         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3248 
3249 
3250     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3251         'Reads this packet from the supplied buffer'
3252         self._bufferstartoffset=buf.getcurrentoffset()
3253         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3254         self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CPBW=,' })
3255         self.__field_command.readfrombuffer(buf)
3256         self.__field_group=CSVINT()
3257         self.__field_group.readfrombuffer(buf)
3258         self.__field_mobile=CSVSTRING(**{ 'default': '',                  'maxsizeinbytes': PB_NUMBER_LEN,                  'raiseontruncate': False })
3259         self.__field_mobile.readfrombuffer(buf)
3260         self.__field_mobile_type=CSVINT(**{ 'default': 255 })
3261         self.__field_mobile_type.readfrombuffer(buf)
3262         self.__field_home=CSVSTRING(**{ 'default': '',                  'maxsizeinbytes': PB_NUMBER_LEN,                  'raiseontruncate': False })
3263         self.__field_home.readfrombuffer(buf)
3264         self.__field_home_type=CSVINT(**{ 'default': 255 })
3265         self.__field_home_type.readfrombuffer(buf)
3266         self.__field_office=CSVSTRING(**{ 'default': '',                  'maxsizeinbytes': PB_NUMBER_LEN,                  'raiseontruncate': False })
3267         self.__field_office.readfrombuffer(buf)
3268         self.__field_office_type=CSVINT(**{ 'default': 255 })
3269         self.__field_office_type.readfrombuffer(buf)
3270         self.__field_name=CSVSTRING(**{ 'maxsizeinbytes': PB_NAME_LEN,                  'raiseontruncate': False })
3271         self.__field_name.readfrombuffer(buf)
3272         self.__field_email=CSVSTRING(**{ 'default': '',                  'maxsizeinbytes': PB_EMAIL_LEN,                  'raiseontruncate': False })
3273         self.__field_email.readfrombuffer(buf)
3274         self.__field_memo=CSVSTRING(**{ 'terminator': None, 'default': '',                  'maxsizeinbytes': PB_MEMO_LEN,                  'raiseontruncate': False })
3275         self.__field_memo.readfrombuffer(buf)
3276         self._bufferendoffset=buf.getcurrentoffset()
3277 
3278 
3279     def __getfield_command(self):
3280         try: self.__field_command
3281         except:
3282             self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CPBW=,' })
3283         return self.__field_command.getvalue()
3284 
3285     def __setfield_command(self, value):
3286         if isinstance(value,USTRING):
3287             self.__field_command=value
3288         else:
3289             self.__field_command=USTRING(value,**{ 'terminator': None, 'default': '+CPBW=,' })
3290 
3291     def __delfield_command(self): del self.__field_command
3292 
3293     command=property(__getfield_command, __setfield_command, __delfield_command, None)
3294 
3295     def __getfield_group(self):
3296         try: self.__field_group
3297         except:
3298             self.__field_group=CSVINT()
3299         return self.__field_group.getvalue()
3300 
3301     def __setfield_group(self, value):
3302         if isinstance(value,CSVINT):
3303             self.__field_group=value
3304         else:
3305             self.__field_group=CSVINT(value,)
3306 
3307     def __delfield_group(self): del self.__field_group
3308 
3309     group=property(__getfield_group, __setfield_group, __delfield_group, None)
3310 
3311     def __getfield_mobile(self):
3312         try: self.__field_mobile
3313         except:
3314             self.__field_mobile=CSVSTRING(**{ 'default': '',                  'maxsizeinbytes': PB_NUMBER_LEN,                  'raiseontruncate': False })
3315         return self.__field_mobile.getvalue()
3316 
3317     def __setfield_mobile(self, value):
3318         if isinstance(value,CSVSTRING):
3319             self.__field_mobile=value
3320         else:
3321             self.__field_mobile=CSVSTRING(value,**{ 'default': '',                  'maxsizeinbytes': PB_NUMBER_LEN,                  'raiseontruncate': False })
3322 
3323     def __delfield_mobile(self): del self.__field_mobile
3324 
3325     mobile=property(__getfield_mobile, __setfield_mobile, __delfield_mobile, None)
3326 
3327     def __getfield_mobile_type(self):
3328         try: self.__field_mobile_type
3329         except:
3330             self.__field_mobile_type=CSVINT(**{ 'default': 255 })
3331         return self.__field_mobile_type.getvalue()
3332 
3333     def __setfield_mobile_type(self, value):
3334         if isinstance(value,CSVINT):
3335             self.__field_mobile_type=value
3336         else:
3337             self.__field_mobile_type=CSVINT(value,**{ 'default': 255 })
3338 
3339     def __delfield_mobile_type(self): del self.__field_mobile_type
3340 
3341     mobile_type=property(__getfield_mobile_type, __setfield_mobile_type, __delfield_mobile_type, None)
3342 
3343     def __getfield_home(self):
3344         try: self.__field_home
3345         except:
3346             self.__field_home=CSVSTRING(**{ 'default': '',                  'maxsizeinbytes': PB_NUMBER_LEN,                  'raiseontruncate': False })
3347         return self.__field_home.getvalue()
3348 
3349     def __setfield_home(self, value):
3350         if isinstance(value,CSVSTRING):
3351             self.__field_home=value
3352         else:
3353             self.__field_home=CSVSTRING(value,**{ 'default': '',                  'maxsizeinbytes': PB_NUMBER_LEN,                  'raiseontruncate': False })
3354 
3355     def __delfield_home(self): del self.__field_home
3356 
3357     home=property(__getfield_home, __setfield_home, __delfield_home, None)
3358 
3359     def __getfield_home_type(self):
3360         try: self.__field_home_type
3361         except:
3362             self.__field_home_type=CSVINT(**{ 'default': 255 })
3363         return self.__field_home_type.getvalue()
3364 
3365     def __setfield_home_type(self, value):
3366         if isinstance(value,CSVINT):
3367             self.__field_home_type=value
3368         else:
3369             self.__field_home_type=CSVINT(value,**{ 'default': 255 })
3370 
3371     def __delfield_home_type(self): del self.__field_home_type
3372 
3373     home_type=property(__getfield_home_type, __setfield_home_type, __delfield_home_type, None)
3374 
3375     def __getfield_office(self):
3376         try: self.__field_office
3377         except:
3378             self.__field_office=CSVSTRING(**{ 'default': '',                  'maxsizeinbytes': PB_NUMBER_LEN,                  'raiseontruncate': False })
3379         return self.__field_office.getvalue()
3380 
3381     def __setfield_office(self, value):
3382         if isinstance(value,CSVSTRING):
3383             self.__field_office=value
3384         else:
3385             self.__field_office=CSVSTRING(value,**{ 'default': '',                  'maxsizeinbytes': PB_NUMBER_LEN,                  'raiseontruncate': False })
3386 
3387     def __delfield_office(self): del self.__field_office
3388 
3389     office=property(__getfield_office, __setfield_office, __delfield_office, None)
3390 
3391     def __getfield_office_type(self):
3392         try: self.__field_office_type
3393         except:
3394             self.__field_office_type=CSVINT(**{ 'default': 255 })
3395         return self.__field_office_type.getvalue()
3396 
3397     def __setfield_office_type(self, value):
3398         if isinstance(value,CSVINT):
3399             self.__field_office_type=value
3400         else:
3401             self.__field_office_type=CSVINT(value,**{ 'default': 255 })
3402 
3403     def __delfield_office_type(self): del self.__field_office_type
3404 
3405     office_type=property(__getfield_office_type, __setfield_office_type, __delfield_office_type, None)
3406 
3407     def __getfield_name(self):
3408         try: self.__field_name
3409         except:
3410             self.__field_name=CSVSTRING(**{ 'maxsizeinbytes': PB_NAME_LEN,                  'raiseontruncate': False })
3411         return self.__field_name.getvalue()
3412 
3413     def __setfield_name(self, value):
3414         if isinstance(value,CSVSTRING):
3415             self.__field_name=value
3416         else:
3417             self.__field_name=CSVSTRING(value,**{ 'maxsizeinbytes': PB_NAME_LEN,                  'raiseontruncate': False })
3418 
3419     def __delfield_name(self): del self.__field_name
3420 
3421     name=property(__getfield_name, __setfield_name, __delfield_name, None)
3422 
3423     def __getfield_email(self):
3424         try: self.__field_email
3425         except:
3426             self.__field_email=CSVSTRING(**{ 'default': '',                  'maxsizeinbytes': PB_EMAIL_LEN,                  'raiseontruncate': False })
3427         return self.__field_email.getvalue()
3428 
3429     def __setfield_email(self, value):
3430         if isinstance(value,CSVSTRING):
3431             self.__field_email=value
3432         else:
3433             self.__field_email=CSVSTRING(value,**{ 'default': '',                  'maxsizeinbytes': PB_EMAIL_LEN,                  'raiseontruncate': False })
3434 
3435     def __delfield_email(self): del self.__field_email
3436 
3437     email=property(__getfield_email, __setfield_email, __delfield_email, None)
3438 
3439     def __getfield_memo(self):
3440         try: self.__field_memo
3441         except:
3442             self.__field_memo=CSVSTRING(**{ 'terminator': None, 'default': '',                  'maxsizeinbytes': PB_MEMO_LEN,                  'raiseontruncate': False })
3443         return self.__field_memo.getvalue()
3444 
3445     def __setfield_memo(self, value):
3446         if isinstance(value,CSVSTRING):
3447             self.__field_memo=value
3448         else:
3449             self.__field_memo=CSVSTRING(value,**{ 'terminator': None, 'default': '',                  'maxsizeinbytes': PB_MEMO_LEN,                  'raiseontruncate': False })
3450 
3451     def __delfield_memo(self): del self.__field_memo
3452 
3453     memo=property(__getfield_memo, __setfield_memo, __delfield_memo, None)
3454 
3455     def iscontainer(self):
3456         return True
3457 
3458     def containerelements(self):
3459         yield ('command', self.__field_command, None)
3460         yield ('group', self.__field_group, None)
3461         yield ('mobile', self.__field_mobile, None)
3462         yield ('mobile_type', self.__field_mobile_type, None)
3463         yield ('home', self.__field_home, None)
3464         yield ('home_type', self.__field_home_type, None)
3465         yield ('office', self.__field_office, None)
3466         yield ('office_type', self.__field_office_type, None)
3467         yield ('name', self.__field_name, None)
3468         yield ('email', self.__field_email, None)
3469         yield ('memo', self.__field_memo, None)
3470 
3471 
3472 
3473 
3474 class write_sim_phonebook_req(BaseProtogenClass):
3475     __fields=['command', 'group', 'number', 'number_type', 'name']
3476 
3477     def __init__(self, *args, **kwargs):
3478         dict={}
3479         # What was supplied to this function
3480         dict.update(kwargs)
3481         # Parent constructor
3482         super(write_sim_phonebook_req,self).__init__(**dict)
3483         if self.__class__ is write_sim_phonebook_req:
3484             self._update(args,dict)
3485 
3486 
3487     def getfields(self):
3488         return self.__fields
3489 
3490 
3491     def _update(self, args, kwargs):
3492         super(write_sim_phonebook_req,self)._update(args,kwargs)
3493         keys=kwargs.keys()
3494         for key in keys:
3495             if key in self.__fields:
3496                 setattr(self, key, kwargs[key])
3497                 del kwargs[key]
3498         # Were any unrecognized kwargs passed in?
3499         if __debug__:
3500             self._complainaboutunusedargs(write_sim_phonebook_req,kwargs)
3501         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3502         # Make all P fields that haven't already been constructed
3503 
3504 
3505     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3506         'Writes this packet to the supplied buffer'
3507         self._bufferstartoffset=buf.getcurrentoffset()
3508         try: self.__field_command
3509         except:
3510             self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CPBW=,' })
3511         self.__field_command.writetobuffer(buf)
3512         try: self.__field_group
3513         except:
3514             self.__field_group=CSVINT(**{ 'default': 0 })
3515         self.__field_group.writetobuffer(buf)
3516         try: self.__field_number
3517         except:
3518             self.__field_number=CSVSTRING(**{ 'default': '',                  'maxsizeinbytes': PB_NUMBER_LEN,                  'raiseontruncate': False })
3519         self.__field_number.writetobuffer(buf)
3520         try: self.__field_number_type
3521         except:
3522             self.__field_number_type=CSVINT(**{ 'default': 255 })
3523         self.__field_number_type.writetobuffer(buf)
3524         try: self.__field_name
3525         except:
3526             self.__field_name=CSVSTRING(**{ 'terminator': None,                  'maxsizeinbytes': PB_SIM_NAME_LEN,                  'raiseontruncate': False })
3527         self.__field_name.writetobuffer(buf)
3528         self._bufferendoffset=buf.getcurrentoffset()
3529         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3530 
3531 
3532     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3533         'Reads this packet from the supplied buffer'
3534         self._bufferstartoffset=buf.getcurrentoffset()
3535         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3536         self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CPBW=,' })
3537         self.__field_command.readfrombuffer(buf)
3538         self.__field_group=CSVINT(**{ 'default': 0 })
3539         self.__field_group.readfrombuffer(buf)
3540         self.__field_number=CSVSTRING(**{ 'default': '',                  'maxsizeinbytes': PB_NUMBER_LEN,                  'raiseontruncate': False })
3541         self.__field_number.readfrombuffer(buf)
3542         self.__field_number_type=CSVINT(**{ 'default': 255 })
3543         self.__field_number_type.readfrombuffer(buf)
3544         self.__field_name=CSVSTRING(**{ 'terminator': None,                  'maxsizeinbytes': PB_SIM_NAME_LEN,                  'raiseontruncate': False })
3545         self.__field_name.readfrombuffer(buf)
3546         self._bufferendoffset=buf.getcurrentoffset()
3547 
3548 
3549     def __getfield_command(self):
3550         try: self.__field_command
3551         except:
3552             self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CPBW=,' })
3553         return self.__field_command.getvalue()
3554 
3555     def __setfield_command(self, value):
3556         if isinstance(value,USTRING):
3557             self.__field_command=value
3558         else:
3559             self.__field_command=USTRING(value,**{ 'terminator': None, 'default': '+CPBW=,' })
3560 
3561     def __delfield_command(self): del self.__field_command
3562 
3563     command=property(__getfield_command, __setfield_command, __delfield_command, None)
3564 
3565     def __getfield_group(self):
3566         try: self.__field_group
3567         except:
3568             self.__field_group=CSVINT(**{ 'default': 0 })
3569         return self.__field_group.getvalue()
3570 
3571     def __setfield_group(self, value):
3572         if isinstance(value,CSVINT):
3573             self.__field_group=value
3574         else:
3575             self.__field_group=CSVINT(value,**{ 'default': 0 })
3576 
3577     def __delfield_group(self): del self.__field_group
3578 
3579     group=property(__getfield_group, __setfield_group, __delfield_group, None)
3580 
3581     def __getfield_number(self):
3582         try: self.__field_number
3583         except:
3584             self.__field_number=CSVSTRING(**{ 'default': '',                  'maxsizeinbytes': PB_NUMBER_LEN,                  'raiseontruncate': False })
3585         return self.__field_number.getvalue()
3586 
3587     def __setfield_number(self, value):
3588         if isinstance(value,CSVSTRING):
3589             self.__field_number=value
3590         else:
3591             self.__field_number=CSVSTRING(value,**{ 'default': '',                  'maxsizeinbytes': PB_NUMBER_LEN,                  'raiseontruncate': False })
3592 
3593     def __delfield_number(self): del self.__field_number
3594 
3595     number=property(__getfield_number, __setfield_number, __delfield_number, None)
3596 
3597     def __getfield_number_type(self):
3598         try: self.__field_number_type
3599         except:
3600             self.__field_number_type=CSVINT(**{ 'default': 255 })
3601         return self.__field_number_type.getvalue()
3602 
3603     def __setfield_number_type(self, value):
3604         if isinstance(value,CSVINT):
3605             self.__field_number_type=value
3606         else:
3607             self.__field_number_type=CSVINT(value,**{ 'default': 255 })
3608 
3609     def __delfield_number_type(self): del self.__field_number_type
3610 
3611     number_type=property(__getfield_number_type, __setfield_number_type, __delfield_number_type, None)
3612 
3613     def __getfield_name(self):
3614         try: self.__field_name
3615         except:
3616             self.__field_name=CSVSTRING(**{ 'terminator': None,                  'maxsizeinbytes': PB_SIM_NAME_LEN,                  'raiseontruncate': False })
3617         return self.__field_name.getvalue()
3618 
3619     def __setfield_name(self, value):
3620         if isinstance(value,CSVSTRING):
3621             self.__field_name=value
3622         else:
3623             self.__field_name=CSVSTRING(value,**{ 'terminator': None,                  'maxsizeinbytes': PB_SIM_NAME_LEN,                  'raiseontruncate': False })
3624 
3625     def __delfield_name(self): del self.__field_name
3626 
3627     name=property(__getfield_name, __setfield_name, __delfield_name, None)
3628 
3629     def iscontainer(self):
3630         return True
3631 
3632     def containerelements(self):
3633         yield ('command', self.__field_command, None)
3634         yield ('group', self.__field_group, None)
3635         yield ('number', self.__field_number, None)
3636         yield ('number_type', self.__field_number_type, None)
3637         yield ('name', self.__field_name, None)
3638 
3639 
3640 
3641 
3642 class memo_read_req(BaseProtogenClass):
3643     __fields=['command', 'start_index', 'end_index']
3644 
3645     def __init__(self, *args, **kwargs):
3646         dict={}
3647         # What was supplied to this function
3648         dict.update(kwargs)
3649         # Parent constructor
3650         super(memo_read_req,self).__init__(**dict)
3651         if self.__class__ is memo_read_req:
3652             self._update(args,dict)
3653 
3654 
3655     def getfields(self):
3656         return self.__fields
3657 
3658 
3659     def _update(self, args, kwargs):
3660         super(memo_read_req,self)._update(args,kwargs)
3661         keys=kwargs.keys()
3662         for key in keys:
3663             if key in self.__fields:
3664                 setattr(self, key, kwargs[key])
3665                 del kwargs[key]
3666         # Were any unrecognized kwargs passed in?
3667         if __debug__:
3668             self._complainaboutunusedargs(memo_read_req,kwargs)
3669         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3670         # Make all P fields that haven't already been constructed
3671 
3672 
3673     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3674         'Writes this packet to the supplied buffer'
3675         self._bufferstartoffset=buf.getcurrentoffset()
3676         try: self.__field_command
3677         except:
3678             self.__field_command=USTRING(**{ 'terminator': None,               'default': MEMO_READ_CMD+'=' })
3679         self.__field_command.writetobuffer(buf)
3680         try: self.__field_start_index
3681         except:
3682             self.__field_start_index=CSVINT(**{ 'default': MEMO_MIN_INDEX })
3683         self.__field_start_index.writetobuffer(buf)
3684         try: self.__field_end_index
3685         except:
3686             self.__field_end_index=CSVINT(**{ 'terminator': None,               'default': MEMO_MAX_INDEX })
3687         self.__field_end_index.writetobuffer(buf)
3688         self._bufferendoffset=buf.getcurrentoffset()
3689         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3690 
3691 
3692     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3693         'Reads this packet from the supplied buffer'
3694         self._bufferstartoffset=buf.getcurrentoffset()
3695         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3696         self.__field_command=USTRING(**{ 'terminator': None,               'default': MEMO_READ_CMD+'=' })
3697         self.__field_command.readfrombuffer(buf)
3698         self.__field_start_index=CSVINT(**{ 'default': MEMO_MIN_INDEX })
3699         self.__field_start_index.readfrombuffer(buf)
3700         self.__field_end_index=CSVINT(**{ 'terminator': None,               'default': MEMO_MAX_INDEX })
3701         self.__field_end_index.readfrombuffer(buf)
3702         self._bufferendoffset=buf.getcurrentoffset()
3703 
3704 
3705     def __getfield_command(self):
3706         try: self.__field_command
3707         except:
3708             self.__field_command=USTRING(**{ 'terminator': None,               'default': MEMO_READ_CMD+'=' })
3709         return self.__field_command.getvalue()
3710 
3711     def __setfield_command(self, value):
3712         if isinstance(value,USTRING):
3713             self.__field_command=value
3714         else:
3715             self.__field_command=USTRING(value,**{ 'terminator': None,               'default': MEMO_READ_CMD+'=' })
3716 
3717     def __delfield_command(self): del self.__field_command
3718 
3719     command=property(__getfield_command, __setfield_command, __delfield_command, None)
3720 
3721     def __getfield_start_index(self):
3722         try: self.__field_start_index
3723         except:
3724             self.__field_start_index=CSVINT(**{ 'default': MEMO_MIN_INDEX })
3725         return self.__field_start_index.getvalue()
3726 
3727     def __setfield_start_index(self, value):
3728         if isinstance(value,CSVINT):
3729             self.__field_start_index=value
3730         else:
3731             self.__field_start_index=CSVINT(value,**{ 'default': MEMO_MIN_INDEX })
3732 
3733     def __delfield_start_index(self): del self.__field_start_index
3734 
3735     start_index=property(__getfield_start_index, __setfield_start_index, __delfield_start_index, None)
3736 
3737     def __getfield_end_index(self):
3738         try: self.__field_end_index
3739         except:
3740             self.__field_end_index=CSVINT(**{ 'terminator': None,               'default': MEMO_MAX_INDEX })
3741         return self.__field_end_index.getvalue()
3742 
3743     def __setfield_end_index(self, value):
3744         if isinstance(value,CSVINT):
3745             self.__field_end_index=value
3746         else:
3747             self.__field_end_index=CSVINT(value,**{ 'terminator': None,               'default': MEMO_MAX_INDEX })
3748 
3749     def __delfield_end_index(self): del self.__field_end_index
3750 
3751     end_index=property(__getfield_end_index, __setfield_end_index, __delfield_end_index, None)
3752 
3753     def iscontainer(self):
3754         return True
3755 
3756     def containerelements(self):
3757         yield ('command', self.__field_command, None)
3758         yield ('start_index', self.__field_start_index, None)
3759         yield ('end_index', self.__field_end_index, None)
3760 
3761 
3762 
3763 
3764 class memo_read_resp(BaseProtogenClass):
3765     __fields=['command', 'index', 'text']
3766 
3767     def __init__(self, *args, **kwargs):
3768         dict={}
3769         # What was supplied to this function
3770         dict.update(kwargs)
3771         # Parent constructor
3772         super(memo_read_resp,self).__init__(**dict)
3773         if self.__class__ is memo_read_resp:
3774             self._update(args,dict)
3775 
3776 
3777     def getfields(self):
3778         return self.__fields
3779 
3780 
3781     def _update(self, args, kwargs):
3782         super(memo_read_resp,self)._update(args,kwargs)
3783         keys=kwargs.keys()
3784         for key in keys:
3785             if key in self.__fields:
3786                 setattr(self, key, kwargs[key])
3787                 del kwargs[key]
3788         # Were any unrecognized kwargs passed in?
3789         if __debug__:
3790             self._complainaboutunusedargs(memo_read_resp,kwargs)
3791         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3792         # Make all P fields that haven't already been constructed
3793 
3794 
3795     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3796         'Writes this packet to the supplied buffer'
3797         self._bufferstartoffset=buf.getcurrentoffset()
3798         self.__field_command.writetobuffer(buf)
3799         self.__field_index.writetobuffer(buf)
3800         self.__field_text.writetobuffer(buf)
3801         self._bufferendoffset=buf.getcurrentoffset()
3802         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3803 
3804 
3805     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3806         'Reads this packet from the supplied buffer'
3807         self._bufferstartoffset=buf.getcurrentoffset()
3808         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3809         self.__field_command=USTRING(**{ 'terminator': ord(' '),               'constant': MEMO_READ_CMD+':' })
3810         self.__field_command.readfrombuffer(buf)
3811         self.__field_index=CSVINT()
3812         self.__field_index.readfrombuffer(buf)
3813         self.__field_text=CSVSTRING(**{ 'terminator': None })
3814         self.__field_text.readfrombuffer(buf)
3815         self._bufferendoffset=buf.getcurrentoffset()
3816 
3817 
3818     def __getfield_command(self):
3819         return self.__field_command.getvalue()
3820 
3821     def __setfield_command(self, value):
3822         if isinstance(value,USTRING):
3823             self.__field_command=value
3824         else:
3825             self.__field_command=USTRING(value,**{ 'terminator': ord(' '),               'constant': MEMO_READ_CMD+':' })
3826 
3827     def __delfield_command(self): del self.__field_command
3828 
3829     command=property(__getfield_command, __setfield_command, __delfield_command, None)
3830 
3831     def __getfield_index(self):
3832         return self.__field_index.getvalue()
3833 
3834     def __setfield_index(self, value):
3835         if isinstance(value,CSVINT):
3836             self.__field_index=value
3837         else:
3838             self.__field_index=CSVINT(value,)
3839 
3840     def __delfield_index(self): del self.__field_index
3841 
3842     index=property(__getfield_index, __setfield_index, __delfield_index, None)
3843 
3844     def __getfield_text(self):
3845         return self.__field_text.getvalue()
3846 
3847     def __setfield_text(self, value):
3848         if isinstance(value,CSVSTRING):
3849             self.__field_text=value
3850         else:
3851             self.__field_text=CSVSTRING(value,**{ 'terminator': None })
3852 
3853     def __delfield_text(self): del self.__field_text
3854 
3855     text=property(__getfield_text, __setfield_text, __delfield_text, None)
3856 
3857     def iscontainer(self):
3858         return True
3859 
3860     def containerelements(self):
3861         yield ('command', self.__field_command, None)
3862         yield ('index', self.__field_index, None)
3863         yield ('text', self.__field_text, None)
3864 
3865 
3866 
3867 
3868 class memo_write_req(BaseProtogenClass):
3869     __fields=['command', 'text']
3870 
3871     def __init__(self, *args, **kwargs):
3872         dict={}
3873         # What was supplied to this function
3874         dict.update(kwargs)
3875         # Parent constructor
3876         super(memo_write_req,self).__init__(**dict)
3877         if self.__class__ is memo_write_req:
3878             self._update(args,dict)
3879 
3880 
3881     def getfields(self):
3882         return self.__fields
3883 
3884 
3885     def _update(self, args, kwargs):
3886         super(memo_write_req,self)._update(args,kwargs)
3887         keys=kwargs.keys()
3888         for key in keys:
3889             if key in self.__fields:
3890                 setattr(self, key, kwargs[key])
3891                 del kwargs[key]
3892         # Were any unrecognized kwargs passed in?
3893         if __debug__:
3894             self._complainaboutunusedargs(memo_write_req,kwargs)
3895         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3896         # Make all P fields that haven't already been constructed
3897 
3898 
3899     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3900         'Writes this packet to the supplied buffer'
3901         self._bufferstartoffset=buf.getcurrentoffset()
3902         try: self.__field_command
3903         except:
3904             self.__field_command=USTRING(**{ 'terminator': None,               'default': MEMO_WRITE_CMD+'=,' })
3905         self.__field_command.writetobuffer(buf)
3906         try: self.__field_text
3907         except:
3908             self.__field_text=CSVSTRING(**{ 'terminator': None })
3909         self.__field_text.writetobuffer(buf)
3910         self._bufferendoffset=buf.getcurrentoffset()
3911         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3912 
3913 
3914     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3915         'Reads this packet from the supplied buffer'
3916         self._bufferstartoffset=buf.getcurrentoffset()
3917         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3918         self.__field_command=USTRING(**{ 'terminator': None,               'default': MEMO_WRITE_CMD+'=,' })
3919         self.__field_command.readfrombuffer(buf)
3920         self.__field_text=CSVSTRING(**{ 'terminator': None })
3921         self.__field_text.readfrombuffer(buf)
3922         self._bufferendoffset=buf.getcurrentoffset()
3923 
3924 
3925     def __getfield_command(self):
3926         try: self.__field_command
3927         except:
3928             self.__field_command=USTRING(**{ 'terminator': None,               'default': MEMO_WRITE_CMD+'=,' })
3929         return self.__field_command.getvalue()
3930 
3931     def __setfield_command(self, value):
3932         if isinstance(value,USTRING):
3933             self.__field_command=value
3934         else:
3935             self.__field_command=USTRING(value,**{ 'terminator': None,               'default': MEMO_WRITE_CMD+'=,' })
3936 
3937     def __delfield_command(self): del self.__field_command
3938 
3939     command=property(__getfield_command, __setfield_command, __delfield_command, None)
3940 
3941     def __getfield_text(self):
3942         try: self.__field_text
3943         except:
3944             self.__field_text=CSVSTRING(**{ 'terminator': None })
3945         return self.__field_text.getvalue()
3946 
3947     def __setfield_text(self, value):
3948         if isinstance(value,CSVSTRING):
3949             self.__field_text=value
3950         else:
3951             self.__field_text=CSVSTRING(value,**{ 'terminator': None })
3952 
3953     def __delfield_text(self): del self.__field_text
3954 
3955     text=property(__getfield_text, __setfield_text, __delfield_text, None)
3956 
3957     def iscontainer(self):
3958         return True
3959 
3960     def containerelements(self):
3961         yield ('command', self.__field_command, None)
3962         yield ('text', self.__field_text, None)
3963 
3964 
3965 
3966 
3967 class memo_del_req(BaseProtogenClass):
3968     __fields=['command', 'index']
3969 
3970     def __init__(self, *args, **kwargs):
3971         dict={}
3972         # What was supplied to this function
3973         dict.update(kwargs)
3974         # Parent constructor
3975         super(memo_del_req,self).__init__(**dict)
3976         if self.__class__ is memo_del_req:
3977             self._update(args,dict)
3978 
3979 
3980     def getfields(self):
3981         return self.__fields
3982 
3983 
3984     def _update(self, args, kwargs):
3985         super(memo_del_req,self)._update(args,kwargs)
3986         keys=kwargs.keys()
3987         for key in keys:
3988             if key in self.__fields:
3989                 setattr(self, key, kwargs[key])
3990                 del kwargs[key]
3991         # Were any unrecognized kwargs passed in?
3992         if __debug__:
3993             self._complainaboutunusedargs(memo_del_req,kwargs)
3994         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3995         # Make all P fields that haven't already been constructed
3996 
3997 
3998     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3999         'Writes this packet to the supplied buffer'
4000         self._bufferstartoffset=buf.getcurrentoffset()
4001         try: self.__field_command
4002         except:
4003             self.__field_command=USTRING(**{ 'terminator': None,               'default': MEMO_WRITE_CMD+'=' })
4004         self.__field_command.writetobuffer(buf)
4005         try: self.__field_index
4006         except:
4007             self.__field_index=CSVINT(**{ 'terminator': None })
4008         self.__field_index.writetobuffer(buf)
4009         self._bufferendoffset=buf.getcurrentoffset()
4010         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
4011 
4012 
4013     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
4014         'Reads this packet from the supplied buffer'
4015         self._bufferstartoffset=buf.getcurrentoffset()
4016         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
4017         self.__field_command=USTRING(**{ 'terminator': None,               'default': MEMO_WRITE_CMD+'=' })
4018         self.__field_command.readfrombuffer(buf)
4019         self.__field_index=CSVINT(**{ 'terminator': None })
4020         self.__field_index.readfrombuffer(buf)
4021         self._bufferendoffset=buf.getcurrentoffset()
4022 
4023 
4024     def __getfield_command(self):
4025         try: self.__field_command
4026         except:
4027             self.__field_command=USTRING(**{ 'terminator': None,               'default': MEMO_WRITE_CMD+'=' })
4028         return self.__field_command.getvalue()
4029 
4030     def __setfield_command(self, value):
4031         if isinstance(value,USTRING):
4032             self.__field_command=value
4033         else:
4034             self.__field_command=USTRING(value,**{ 'terminator': None,               'default': MEMO_WRITE_CMD+'=' })
4035 
4036     def __delfield_command(self): del self.__field_command
4037 
4038     command=property(__getfield_command, __setfield_command, __delfield_command, None)
4039 
4040     def __getfield_index(self):
4041         try: self.__field_index
4042         except:
4043             self.__field_index=CSVINT(**{ 'terminator': None })
4044         return self.__field_index.getvalue()
4045 
4046     def __setfield_index(self, value):
4047         if isinstance(value,CSVINT):
4048             self.__field_index=value
4049         else:
4050             self.__field_index=CSVINT(value,**{ 'terminator': None })
4051 
4052     def __delfield_index(self): del self.__field_index
4053 
4054     index=property(__getfield_index, __setfield_index, __delfield_index, None)
4055 
4056     def iscontainer(self):
4057         return True
4058 
4059     def containerelements(self):
4060         yield ('command', self.__field_command, None)
4061         yield ('index', self.__field_index, None)
4062 
4063 
4064 
4065 
4066 class sms_format_req(BaseProtogenClass):
4067     __fields=['command', 'format']
4068 
4069     def __init__(self, *args, **kwargs):
4070         dict={}
4071         # What was supplied to this function
4072         dict.update(kwargs)
4073         # Parent constructor
4074         super(sms_format_req,self).__init__(**dict)
4075         if self.__class__ is sms_format_req:
4076             self._update(args,dict)
4077 
4078 
4079     def getfields(self):
4080         return self.__fields
4081 
4082 
4083     def _update(self, args, kwargs):
4084         super(sms_format_req,self)._update(args,kwargs)
4085         keys=kwargs.keys()
4086         for key in keys:
4087             if key in self.__fields:
4088                 setattr(self, key, kwargs[key])
4089                 del kwargs[key]
4090         # Were any unrecognized kwargs passed in?
4091         if __debug__:
4092             self._complainaboutunusedargs(sms_format_req,kwargs)
4093         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
4094         # Make all P fields that haven't already been constructed
4095 
4096 
4097     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
4098         'Writes this packet to the supplied buffer'
4099         self._bufferstartoffset=buf.getcurrentoffset()
4100         try: self.__field_command
4101         except:
4102             self.__field_command=USTRING(**{ 'terminator': None,               'default': SMS_FORMAT_CMD+'=' })
4103         self.__field_command.writetobuffer(buf)
4104         try: self.__field_format
4105         except:
4106             self.__field_format=CSVINT(**{ 'terminator': None,               'default': SMS_FORMAT_TEXT })
4107         self.__field_format.writetobuffer(buf)
4108         self._bufferendoffset=buf.getcurrentoffset()
4109         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
4110 
4111 
4112     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
4113         'Reads this packet from the supplied buffer'
4114         self._bufferstartoffset=buf.getcurrentoffset()
4115         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
4116         self.__field_command=USTRING(**{ 'terminator': None,               'default': SMS_FORMAT_CMD+'=' })
4117         self.__field_command.readfrombuffer(buf)
4118         self.__field_format=CSVINT(**{ 'terminator': None,               'default': SMS_FORMAT_TEXT })
4119         self.__field_format.readfrombuffer(buf)
4120         self._bufferendoffset=buf.getcurrentoffset()
4121 
4122 
4123     def __getfield_command(self):
4124         try: self.__field_command
4125         except:
4126             self.__field_command=USTRING(**{ 'terminator': None,               'default': SMS_FORMAT_CMD+'=' })
4127         return self.__field_command.getvalue()
4128 
4129     def __setfield_command(self, value):
4130         if isinstance(value,USTRING):
4131             self.__field_command=value
4132         else:
4133             self.__field_command=USTRING(value,**{ 'terminator': None,               'default': SMS_FORMAT_CMD+'=' })
4134 
4135     def __delfield_command(self): del self.__field_command
4136 
4137     command=property(__getfield_command, __setfield_command, __delfield_command, None)
4138 
4139     def __getfield_format(self):
4140         try: self.__field_format
4141         except:
4142             self.__field_format=CSVINT(**{ 'terminator': None,               'default': SMS_FORMAT_TEXT })
4143         return self.__field_format.getvalue()
4144 
4145     def __setfield_format(self, value):
4146         if isinstance(value,CSVINT):
4147             self.__field_format=value
4148         else:
4149             self.__field_format=CSVINT(value,**{ 'terminator': None,               'default': SMS_FORMAT_TEXT })
4150 
4151     def __delfield_format(self): del self.__field_format
4152 
4153     format=property(__getfield_format, __setfield_format, __delfield_format, None)
4154 
4155     def iscontainer(self):
4156         return True
4157 
4158     def containerelements(self):
4159         yield ('command', self.__field_command, None)
4160         yield ('format', self.__field_format, None)
4161 
4162 
4163 
4164 
4165 class sms_memory_select_req(BaseProtogenClass):
4166     __fields=['command', 'list_memory']
4167 
4168     def __init__(self, *args, **kwargs):
4169         dict={}
4170         # What was supplied to this function
4171         dict.update(kwargs)
4172         # Parent constructor
4173         super(sms_memory_select_req,self).__init__(**dict)
4174         if self.__class__ is sms_memory_select_req:
4175             self._update(args,dict)
4176 
4177 
4178     def getfields(self):
4179         return self.__fields
4180 
4181 
4182     def _update(self, args, kwargs):
4183         super(sms_memory_select_req,self)._update(args,kwargs)
4184         keys=kwargs.keys()
4185         for key in keys:
4186             if key in self.__fields:
4187                 setattr(self, key, kwargs[key])
4188                 del kwargs[key]
4189         # Were any unrecognized kwargs passed in?
4190         if __debug__:
4191             self._complainaboutunusedargs(sms_memory_select_req,kwargs)
4192         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
4193         # Make all P fields that haven't already been constructed
4194 
4195 
4196     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
4197         'Writes this packet to the supplied buffer'
4198         self._bufferstartoffset=buf.getcurrentoffset()
4199         try: self.__field_command
4200         except:
4201             self.__field_command=USTRING(**{ 'terminator': None,               'default': SMS_MEMORY_SELECT_CMD+'=' })
4202         self.__field_command.writetobuffer(buf)
4203         try: self.__field_list_memory
4204         except:
4205             self.__field_list_memory=CSVSTRING(**{ 'terminator': None })
4206         self.__field_list_memory.writetobuffer(buf)
4207         self._bufferendoffset=buf.getcurrentoffset()
4208         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
4209 
4210 
4211     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
4212         'Reads this packet from the supplied buffer'
4213         self._bufferstartoffset=buf.getcurrentoffset()
4214         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
4215         self.__field_command=USTRING(**{ 'terminator': None,               'default': SMS_MEMORY_SELECT_CMD+'=' })
4216         self.__field_command.readfrombuffer(buf)
4217         self.__field_list_memory=CSVSTRING(**{ 'terminator': None })
4218         self.__field_list_memory.readfrombuffer(buf)
4219         self._bufferendoffset=buf.getcurrentoffset()
4220 
4221 
4222     def __getfield_command(self):
4223         try: self.__field_command
4224         except:
4225             self.__field_command=USTRING(**{ 'terminator': None,               'default': SMS_MEMORY_SELECT_CMD+'=' })
4226         return self.__field_command.getvalue()
4227 
4228     def __setfield_command(self, value):
4229         if isinstance(value,USTRING):
4230             self.__field_command=value
4231         else:
4232             self.__field_command=USTRING(value,**{ 'terminator': None,               'default': SMS_MEMORY_SELECT_CMD+'=' })
4233 
4234     def __delfield_command(self): del self.__field_command
4235 
4236     command=property(__getfield_command, __setfield_command, __delfield_command, None)
4237 
4238     def __getfield_list_memory(self):
4239         try: self.__field_list_memory
4240         except:
4241             self.__field_list_memory=CSVSTRING(**{ 'terminator': None })
4242         return self.__field_list_memory.getvalue()
4243 
4244     def __setfield_list_memory(self, value):
4245         if isinstance(value,CSVSTRING):
4246             self.__field_list_memory=value
4247         else:
4248             self.__field_list_memory=CSVSTRING(value,**{ 'terminator': None })
4249 
4250     def __delfield_list_memory(self): del self.__field_list_memory
4251 
4252     list_memory=property(__getfield_list_memory, __setfield_list_memory, __delfield_list_memory, None)
4253 
4254     def iscontainer(self):
4255         return True
4256 
4257     def containerelements(self):
4258         yield ('command', self.__field_command, None)
4259         yield ('list_memory', self.__field_list_memory, None)
4260 
4261 
4262 
4263 
4264 class sms_msg_list_req(BaseProtogenClass):
4265     __fields=['command', 'msg_type']
4266 
4267     def __init__(self, *args, **kwargs):
4268         dict={}
4269         # What was supplied to this function
4270         dict.update(kwargs)
4271         # Parent constructor
4272         super(sms_msg_list_req,self).__init__(**dict)
4273         if self.__class__ is sms_msg_list_req:
4274             self._update(args,dict)
4275 
4276 
4277     def getfields(self):
4278         return self.__fields
4279 
4280 
4281     def _update(self, args, kwargs):
4282         super(sms_msg_list_req,self)._update(args,kwargs)
4283         keys=kwargs.keys()
4284         for key in keys:
4285             if key in self.__fields:
4286                 setattr(self, key, kwargs[key])
4287                 del kwargs[key]
4288         # Were any unrecognized kwargs passed in?
4289         if __debug__:
4290             self._complainaboutunusedargs(sms_msg_list_req,kwargs)
4291         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
4292         # Make all P fields that haven't already been constructed
4293 
4294 
4295     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
4296         'Writes this packet to the supplied buffer'
4297         self._bufferstartoffset=buf.getcurrentoffset()
4298         try: self.__field_command
4299         except:
4300             self.__field_command=USTRING(**{ 'terminator': None,               'default': SMS_MSG_LIST_CMD+'=' })
4301         self.__field_command.writetobuffer(buf)
4302         try: self.__field_msg_type
4303         except:
4304             self.__field_msg_type=CSVSTRING(**{ 'terminator': None,                  'default': SMS_MSG_ALL })
4305         self.__field_msg_type.writetobuffer(buf)
4306         self._bufferendoffset=buf.getcurrentoffset()
4307         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
4308 
4309 
4310     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
4311         'Reads this packet from the supplied buffer'
4312         self._bufferstartoffset=buf.getcurrentoffset()
4313         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
4314         self.__field_command=USTRING(**{ 'terminator': None,               'default': SMS_MSG_LIST_CMD+'=' })
4315         self.__field_command.readfrombuffer(buf)
4316         self.__field_msg_type=CSVSTRING(**{ 'terminator': None,                  'default': SMS_MSG_ALL })
4317         self.__field_msg_type.readfrombuffer(buf)
4318         self._bufferendoffset=buf.getcurrentoffset()
4319 
4320 
4321     def __getfield_command(self):
4322         try: self.__field_command
4323         except:
4324             self.__field_command=USTRING(**{ 'terminator': None,               'default': SMS_MSG_LIST_CMD+'=' })
4325         return self.__field_command.getvalue()
4326 
4327     def __setfield_command(self, value):
4328         if isinstance(value,USTRING):
4329             self.__field_command=value
4330         else:
4331             self.__field_command=USTRING(value,**{ 'terminator': None,               'default': SMS_MSG_LIST_CMD+'=' })
4332 
4333     def __delfield_command(self): del self.__field_command
4334 
4335     command=property(__getfield_command, __setfield_command, __delfield_command, None)
4336 
4337     def __getfield_msg_type(self):
4338         try: self.__field_msg_type
4339         except:
4340             self.__field_msg_type=CSVSTRING(**{ 'terminator': None,                  'default': SMS_MSG_ALL })
4341         return self.__field_msg_type.getvalue()
4342 
4343     def __setfield_msg_type(self, value):
4344         if isinstance(value,CSVSTRING):
4345             self.__field_msg_type=value
4346         else:
4347             self.__field_msg_type=CSVSTRING(value,**{ 'terminator': None,                  'default': SMS_MSG_ALL })
4348 
4349     def __delfield_msg_type(self): del self.__field_msg_type
4350 
4351     msg_type=property(__getfield_msg_type, __setfield_msg_type, __delfield_msg_type, None)
4352 
4353     def iscontainer(self):
4354         return True
4355 
4356     def containerelements(self):
4357         yield ('command', self.__field_command, None)
4358         yield ('msg_type', self.__field_msg_type, None)
4359 
4360 
4361 
4362 
4363 class sms_msg_list_header(BaseProtogenClass):
4364     __fields=['command', 'index', 'msg_type', 'address', 'address_name', 'timestamp', 'address_type', 'data_len']
4365 
4366     def __init__(self, *args, **kwargs):
4367         dict={}
4368         # What was supplied to this function
4369         dict.update(kwargs)
4370         # Parent constructor
4371         super(sms_msg_list_header,self).__init__(**dict)
4372         if self.__class__ is sms_msg_list_header:
4373             self._update(args,dict)
4374 
4375 
4376     def getfields(self):
4377         return self.__fields
4378 
4379 
4380     def _update(self, args, kwargs):
4381         super(sms_msg_list_header,self)._update(args,kwargs)
4382         keys=kwargs.keys()
4383         for key in keys:
4384             if key in self.__fields:
4385                 setattr(self, key, kwargs[key])
4386                 del kwargs[key]
4387         # Were any unrecognized kwargs passed in?
4388         if __debug__:
4389             self._complainaboutunusedargs(sms_msg_list_header,kwargs)
4390         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
4391         # Make all P fields that haven't already been constructed
4392 
4393 
4394     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
4395         'Writes this packet to the supplied buffer'
4396         self._bufferstartoffset=buf.getcurrentoffset()
4397         self.__field_command.writetobuffer(buf)
4398         self.__field_index.writetobuffer(buf)
4399         self.__field_msg_type.writetobuffer(buf)
4400         self.__field_address.writetobuffer(buf)
4401         self.__field_address_name.writetobuffer(buf)
4402         self.__field_timestamp.writetobuffer(buf)
4403         self.__field_address_type.writetobuffer(buf)
4404         self.__field_data_len.writetobuffer(buf)
4405         self._bufferendoffset=buf.getcurrentoffset()
4406         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
4407 
4408 
4409     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
4410         'Reads this packet from the supplied buffer'
4411         self._bufferstartoffset=buf.getcurrentoffset()
4412         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
4413         self.__field_command=USTRING(**{ 'terminator': ord(' '),               'constant': SMS_MSG_LIST_CMD+':' })
4414         self.__field_command.readfrombuffer(buf)
4415         self.__field_index=CSVINT()
4416         self.__field_index.readfrombuffer(buf)
4417         self.__field_msg_type=CSVSTRING()
4418         self.__field_msg_type.readfrombuffer(buf)
4419         self.__field_address=CSVSTRING()
4420         self.__field_address.readfrombuffer(buf)
4421         self.__field_address_name=CSVSTRING()
4422         self.__field_address_name.readfrombuffer(buf)
4423         self.__field_timestamp=SMSDATETIME()
4424         self.__field_timestamp.readfrombuffer(buf)
4425         self.__field_address_type=CSVINT()
4426         self.__field_address_type.readfrombuffer(buf)
4427         self.__field_data_len=CSVINT(**{ 'terminator': None })
4428         self.__field_data_len.readfrombuffer(buf)
4429         self._bufferendoffset=buf.getcurrentoffset()
4430 
4431 
4432     def __getfield_command(self):
4433         return self.__field_command.getvalue()
4434 
4435     def __setfield_command(self, value):
4436         if isinstance(value,USTRING):
4437             self.__field_command=value
4438         else:
4439             self.__field_command=USTRING(value,**{ 'terminator': ord(' '),               'constant': SMS_MSG_LIST_CMD+':' })
4440 
4441     def __delfield_command(self): del self.__field_command
4442 
4443     command=property(__getfield_command, __setfield_command, __delfield_command, None)
4444 
4445     def __getfield_index(self):
4446         return self.__field_index.getvalue()
4447 
4448     def __setfield_index(self, value):
4449         if isinstance(value,CSVINT):
4450             self.__field_index=value
4451         else:
4452             self.__field_index=CSVINT(value,)
4453 
4454     def __delfield_index(self): del self.__field_index
4455 
4456     index=property(__getfield_index, __setfield_index, __delfield_index, None)
4457 
4458     def __getfield_msg_type(self):
4459         return self.__field_msg_type.getvalue()
4460 
4461     def __setfield_msg_type(self, value):
4462         if isinstance(value,CSVSTRING):
4463             self.__field_msg_type=value
4464         else:
4465             self.__field_msg_type=CSVSTRING(value,)
4466 
4467     def __delfield_msg_type(self): del self.__field_msg_type
4468 
4469     msg_type=property(__getfield_msg_type, __setfield_msg_type, __delfield_msg_type, None)
4470 
4471     def __getfield_address(self):
4472         return self.__field_address.getvalue()
4473 
4474     def __setfield_address(self, value):
4475         if isinstance(value,CSVSTRING):
4476             self.__field_address=value
4477         else:
4478             self.__field_address=CSVSTRING(value,)
4479 
4480     def __delfield_address(self): del self.__field_address
4481 
4482     address=property(__getfield_address, __setfield_address, __delfield_address, None)
4483 
4484     def __getfield_address_name(self):
4485         return self.__field_address_name.getvalue()
4486 
4487     def __setfield_address_name(self, value):
4488         if isinstance(value,CSVSTRING):
4489             self.__field_address_name=value
4490         else:
4491             self.__field_address_name=CSVSTRING(value,)
4492 
4493     def __delfield_address_name(self): del self.__field_address_name
4494 
4495     address_name=property(__getfield_address_name, __setfield_address_name, __delfield_address_name, None)
4496 
4497     def __getfield_timestamp(self):
4498         return self.__field_timestamp.getvalue()
4499 
4500     def __setfield_timestamp(self, value):
4501         if isinstance(value,SMSDATETIME):
4502             self.__field_timestamp=value
4503         else:
4504             self.__field_timestamp=SMSDATETIME(value,)
4505 
4506     def __delfield_timestamp(self): del self.__field_timestamp
4507 
4508     timestamp=property(__getfield_timestamp, __setfield_timestamp, __delfield_timestamp, None)
4509 
4510     def __getfield_address_type(self):
4511         return self.__field_address_type.getvalue()
4512 
4513     def __setfield_address_type(self, value):
4514         if isinstance(value,CSVINT):
4515             self.__field_address_type=value
4516         else:
4517             self.__field_address_type=CSVINT(value,)
4518 
4519     def __delfield_address_type(self): del self.__field_address_type
4520 
4521     address_type=property(__getfield_address_type, __setfield_address_type, __delfield_address_type, None)
4522 
4523     def __getfield_data_len(self):
4524         return self.__field_data_len.getvalue()
4525 
4526     def __setfield_data_len(self, value):
4527         if isinstance(value,CSVINT):
4528             self.__field_data_len=value
4529         else:
4530             self.__field_data_len=CSVINT(value,**{ 'terminator': None })
4531 
4532     def __delfield_data_len(self): del self.__field_data_len
4533 
4534     data_len=property(__getfield_data_len, __setfield_data_len, __delfield_data_len, None)
4535 
4536     def iscontainer(self):
4537         return True
4538 
4539     def containerelements(self):
4540         yield ('command', self.__field_command, None)
4541         yield ('index', self.__field_index, None)
4542         yield ('msg_type', self.__field_msg_type, None)
4543         yield ('address', self.__field_address, None)
4544         yield ('address_name', self.__field_address_name, None)
4545         yield ('timestamp', self.__field_timestamp, None)
4546         yield ('address_type', self.__field_address_type, None)
4547         yield ('data_len', self.__field_data_len, None)
4548 
4549 
4550 
4551 
4552 

Generated by PyXR 0.9.4