0001
0003 """Various descriptions of data specific to LG G4015"""
0004
0005 from prototypes import *
0006 from prototypeslg import *
0007
0008 from p_etsi import *
0010 from p_lg import *
0011
0012 UINT=UINTlsb
0014 BOOL=BOOLlsb
0015
0016 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 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 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
0075 PB_NAME_LEN=20
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_MIN_INDEX=0
0095 MEMO_MAX_INDEX=19
0096 MEMO_READ_CMD='+CMDR'
0097 MEMO_WRITE_CMD='+CMDW'
0098
0099 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 dict.update(kwargs)
0120 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 if __debug__:
0139 self._complainaboutunusedargs(calendar_read_req,kwargs)
0140 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0141
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 dict.update(kwargs)
0242 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 if __debug__:
0261 self._complainaboutunusedargs(calendar_read_resp,kwargs)
0262 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0263
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 dict.update(kwargs)
0414 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 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
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 dict.update(kwargs)
0494 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 if __debug__:
0513 self._complainaboutunusedargs(calendar_write_check_resp,kwargs)
0514 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0515
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 dict.update(kwargs)
0581 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 if __debug__:
0600 self._complainaboutunusedargs(calendar_write_req,kwargs)
0601 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0602
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 dict.update(kwargs)
0795 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 if __debug__:
0814 self._complainaboutunusedargs(calendar_del_req,kwargs)
0815 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0816
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 dict.update(kwargs)
0894 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 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
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 dict.update(kwargs)
0974 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 if __debug__:
0993 self._complainaboutunusedargs(media_selector_resp,kwargs)
0994 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0995
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 dict.update(kwargs)
1061 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 if __debug__:
1080 self._complainaboutunusedargs(media_selector_set,kwargs)
1081 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1082
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 dict.update(kwargs)
1160 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 if __debug__:
1179 self._complainaboutunusedargs(media_list_req,kwargs)
1180 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1181
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 dict.update(kwargs)
1282 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 if __debug__:
1301 self._complainaboutunusedargs(media_list_resp,kwargs)
1302 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1303
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 dict.update(kwargs)
1403 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 if __debug__:
1422 self._complainaboutunusedargs(del_media_req,kwargs)
1423 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1424
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 dict.update(kwargs)
1502 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 if __debug__:
1521 self._complainaboutunusedargs(write_media_req,kwargs)
1522 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1523
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 dict.update(kwargs)
1773 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 if __debug__:
1792 self._complainaboutunusedargs(list_group_req,kwargs)
1793 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1794
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 dict.update(kwargs)
1895 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 if __debug__:
1914 self._complainaboutunusedargs(list_group_resp,kwargs)
1915 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1916
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 dict.update(kwargs)
1999 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 if __debug__:
2018 self._complainaboutunusedargs(charset_set_req,kwargs)
2019 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2020
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 dict.update(kwargs)
2098 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 if __debug__:
2117 self._complainaboutunusedargs(select_storage_req,kwargs)
2118 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2119
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 dict.update(kwargs)
2197 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 if __debug__:
2216 self._complainaboutunusedargs(select_storage_resp,kwargs)
2217 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2218
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 dict.update(kwargs)
2335 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 if __debug__:
2354 self._complainaboutunusedargs(read_phonebook_req,kwargs)
2355 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2356
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 dict.update(kwargs)
2457 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 if __debug__:
2476 self._complainaboutunusedargs(read_phonebook_resp,kwargs)
2477 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2478 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 dict.update(kwargs)
2734 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 if __debug__:
2753 self._complainaboutunusedargs(read_sim_phonebook_resp,kwargs)
2754 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2755 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_t