0001
0003 """Various descriptions of data specific to LG C2000"""
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 MEDIA_PHOTO=6
0020 GROUP_INDEX_RANGE=xrange(8)
0021 MIN_RINGTONE_INDEX=0
0022 MAX_RINGTONE_INDEX=19
0023 MIN_WALLPAPER_INDEX=0
0024 MAX_WALLPAPER_INDEX=19
0025 MIN_PHOTO_INDEX=0
0026 MAX_PHOTO_INDEX=19
0027 CHARSET_IRA='IRA'
0028 CHARSET_BASE64='Base64'
0029 CHARSET_GSM='GSM'
0030 CHARSET_HEX='HEX'
0031 CHARSET_PCCP437='PCCP437'
0032 CHARSET_PCDN='PCDN'
0033 CHARSET_8859_1='8859-1'
0034 CHARSET_UCS2='UCS2'
0035
0036 CAL_TOTAL_ENTRIES=30
0038 CAL_MIN_INDEX=0
0039 CAL_MAX_INDEX=29
0040 CAL_DESC_LEN=30
0041
0042 CAL_REP_NONE=0
0043 CAL_REP_DAILY=1
0044 CAL_REP_WEEKLY=2
0045 CAL_REP_MONTHLY=3
0046 CAL_REP_YEARLY=4
0047
0048 CAL_ALARM_NONE=0
0049 CAL_ALARM_ONTIME=1
0050 CAL_ALARM_15MIN=2
0051 CAL_ALARM_30MIN=3
0052 CAL_ALARM_1HR=4
0053 CAL_ALARM_1DAY=5
0054 CAL_ALARM_VALUE={
0055 CAL_ALARM_NONE: -1,
0056 CAL_ALARM_ONTIME: 0,
0057 CAL_ALARM_15MIN: 15,
0058 CAL_ALARM_30MIN: 30,
0059 CAL_ALARM_1HR: 60,
0060 CAL_ALARM_1DAY: 1440 }
0061 CAL_ALARM_LIST=((1440, CAL_ALARM_1DAY), (60, CAL_ALARM_1HR),
0062 (30, CAL_ALARM_30MIN), (15, CAL_ALARM_15MIN),
0063 (0, CAL_ALARM_ONTIME), (-1, CAL_ALARM_NONE))
0064
0065 PB_MEMORY_SIM='AD'
0067 PB_MEMORY_MAIN='ME'
0068 PB_MEMORY_LAST_DIALED='LD'
0069 PB_MEMORY_LAST_RECEIVED='LR'
0070 PB_MEMORY_LAST_MISSED='LM'
0071 PB_MAIN_TOTAL_ENTRIES=255
0072 PB_MAIN_MIN_INDEX=1
0073 PB_MAIN_MAX_INDEX=254
0074 PB_SIM_TOTAL_ENTRIES=250
0075 PB_SIM_MIN_INDEX=1
0076 PB_SIM_MAX_INDEX=250
0077 PB_NUMBER_LEN=40
0078 PB_NAME_LEN=20
0079 PB_EMAIL_LEN=40
0080 PB_MEMO_LEN=50
0081 PB_SIM_NAME_LEN=16
0082 PB_LD_MIN_INDEX=1
0083 PB_LD_MAX_INDEX=10
0084 PB_LR_MIN_INDEX=1
0085 PB_LR_MAX_INDEX=20
0086 PB_LM_MIN_INDEX=1
0087 PB_LM_MAX_INDEX=10
0088 PB_CALL_HISTORY_INFO=(
0089 ('Getting Last Dialed Calls', PB_MEMORY_LAST_DIALED,
0090 PB_LD_MIN_INDEX, PB_LD_MAX_INDEX),
0091 ('Getting Last Received Calls', PB_MEMORY_LAST_RECEIVED,
0092 PB_LR_MIN_INDEX, PB_LR_MAX_INDEX),
0093 ('Getting Missed Calls', PB_MEMORY_LAST_MISSED,
0094 PB_LM_MIN_INDEX, PB_LM_MAX_INDEX))
0095
0096 MEMO_MIN_INDEX=0
0098 MEMO_MAX_INDEX=19
0099 MEMO_READ_CMD='+CMDR'
0100 MEMO_WRITE_CMD='+CMDW'
0101
0102 SMS_MEMORY_PHONE='ME'
0104 SMS_MEMORY_SIM='SM'
0105 SMS_MEMORY_SELECT_CMD='+CPMS'
0106 SMS_FORMAT_TEXT=1
0107 SMS_FORMAT_PDU=0
0108 SMS_FORMAT_CMD='+CMGF'
0109 SMS_MSG_REC_UNREAD='REC UNREAD'
0110 SMS_MSG_REC_READ='REC READ'
0111 SMS_MSG_STO_UNSENT='STO UNSENT'
0112 SMS_MSG_STO_SENT='STO SENT'
0113 SMS_MSG_ALL='ALL'
0114 SMS_MSG_LIST_CMD='+CMGL'
0115
0116 class calendar_read_req(BaseProtogenClass):
0117 __fields=['command', 'start_index', 'end_index']
0118
0119 def __init__(self, *args, **kwargs):
0120 dict={}
0121 dict.update(kwargs)
0123 super(calendar_read_req,self).__init__(**dict)
0125 if self.__class__ is calendar_read_req:
0126 self._update(args,dict)
0127
0128
0129 def getfields(self):
0130 return self.__fields
0131
0132
0133 def _update(self, args, kwargs):
0134 super(calendar_read_req,self)._update(args,kwargs)
0135 keys=kwargs.keys()
0136 for key in keys:
0137 if key in self.__fields:
0138 setattr(self, key, kwargs[key])
0139 del kwargs[key]
0140 if __debug__:
0142 self._complainaboutunusedargs(calendar_read_req,kwargs)
0143 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0144
0146
0147 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0148 'Writes this packet to the supplied buffer'
0149 self._bufferstartoffset=buf.getcurrentoffset()
0150 try: self.__field_command
0151 except:
0152 self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CXDR=' })
0153 self.__field_command.writetobuffer(buf)
0154 try: self.__field_start_index
0155 except:
0156 self.__field_start_index=CSVINT()
0157 self.__field_start_index.writetobuffer(buf)
0158 try: self.__field_end_index
0159 except:
0160 self.__field_end_index=CSVINT(**{ 'terminator': None })
0161 self.__field_end_index.writetobuffer(buf)
0162 self._bufferendoffset=buf.getcurrentoffset()
0163 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0164
0165
0166 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0167 'Reads this packet from the supplied buffer'
0168 self._bufferstartoffset=buf.getcurrentoffset()
0169 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0170 self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CXDR=' })
0171 self.__field_command.readfrombuffer(buf)
0172 self.__field_start_index=CSVINT()
0173 self.__field_start_index.readfrombuffer(buf)
0174 self.__field_end_index=CSVINT(**{ 'terminator': None })
0175 self.__field_end_index.readfrombuffer(buf)
0176 self._bufferendoffset=buf.getcurrentoffset()
0177
0178
0179 def __getfield_command(self):
0180 try: self.__field_command
0181 except:
0182 self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CXDR=' })
0183 return self.__field_command.getvalue()
0184
0185 def __setfield_command(self, value):
0186 if isinstance(value,USTRING):
0187 self.__field_command=value
0188 else:
0189 self.__field_command=USTRING(value,**{ 'terminator': None, 'default': '+CXDR=' })
0190
0191 def __delfield_command(self): del self.__field_command
0192
0193 command=property(__getfield_command, __setfield_command, __delfield_command, None)
0194
0195 def __getfield_start_index(self):
0196 try: self.__field_start_index
0197 except:
0198 self.__field_start_index=CSVINT()
0199 return self.__field_start_index.getvalue()
0200
0201 def __setfield_start_index(self, value):
0202 if isinstance(value,CSVINT):
0203 self.__field_start_index=value
0204 else:
0205 self.__field_start_index=CSVINT(value,)
0206
0207 def __delfield_start_index(self): del self.__field_start_index
0208
0209 start_index=property(__getfield_start_index, __setfield_start_index, __delfield_start_index, None)
0210
0211 def __getfield_end_index(self):
0212 try: self.__field_end_index
0213 except:
0214 self.__field_end_index=CSVINT(**{ 'terminator': None })
0215 return self.__field_end_index.getvalue()
0216
0217 def __setfield_end_index(self, value):
0218 if isinstance(value,CSVINT):
0219 self.__field_end_index=value
0220 else:
0221 self.__field_end_index=CSVINT(value,**{ 'terminator': None })
0222
0223 def __delfield_end_index(self): del self.__field_end_index
0224
0225 end_index=property(__getfield_end_index, __setfield_end_index, __delfield_end_index, None)
0226
0227 def iscontainer(self):
0228 return True
0229
0230 def containerelements(self):
0231 yield ('command', self.__field_command, None)
0232 yield ('start_index', self.__field_start_index, None)
0233 yield ('end_index', self.__field_end_index, None)
0234
0235
0236
0237
0238 class calendar_read_resp(BaseProtogenClass):
0239 __fields=['command', 'index', 'repeat', 'alarm', 'date', 'time', 'description']
0240
0241 def __init__(self, *args, **kwargs):
0242 dict={}
0243 dict.update(kwargs)
0245 super(calendar_read_resp,self).__init__(**dict)
0247 if self.__class__ is calendar_read_resp:
0248 self._update(args,dict)
0249
0250
0251 def getfields(self):
0252 return self.__fields
0253
0254
0255 def _update(self, args, kwargs):
0256 super(calendar_read_resp,self)._update(args,kwargs)
0257 keys=kwargs.keys()
0258 for key in keys:
0259 if key in self.__fields:
0260 setattr(self, key, kwargs[key])
0261 del kwargs[key]
0262 if __debug__:
0264 self._complainaboutunusedargs(calendar_read_resp,kwargs)
0265 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0266
0268
0269 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0270 'Writes this packet to the supplied buffer'
0271 self._bufferstartoffset=buf.getcurrentoffset()
0272 self.__field_command.writetobuffer(buf)
0273 self.__field_index.writetobuffer(buf)
0274 self.__field_repeat.writetobuffer(buf)
0275 self.__field_alarm.writetobuffer(buf)
0276 self.__field_date.writetobuffer(buf)
0277 self.__field_time.writetobuffer(buf)
0278 self.__field_description.writetobuffer(buf)
0279 self._bufferendoffset=buf.getcurrentoffset()
0280 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0281
0282
0283 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0284 'Reads this packet from the supplied buffer'
0285 self._bufferstartoffset=buf.getcurrentoffset()
0286 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0287 self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': ord(' '), 'constant': '+CXDR:'})
0288 self.__field_command.readfrombuffer(buf)
0289 self.__field_index=CSVINT()
0290 self.__field_index.readfrombuffer(buf)
0291 self.__field_repeat=CSVINT()
0292 self.__field_repeat.readfrombuffer(buf)
0293 self.__field_alarm=CSVINT()
0294 self.__field_alarm.readfrombuffer(buf)
0295 self.__field_date=GSMCALDATE()
0296 self.__field_date.readfrombuffer(buf)
0297 self.__field_time=GSMCALTIME()
0298 self.__field_time.readfrombuffer(buf)
0299 self.__field_description=CSVSTRING(**{ 'terminator': None })
0300 self.__field_description.readfrombuffer(buf)
0301 self._bufferendoffset=buf.getcurrentoffset()
0302
0303
0304 def __getfield_command(self):
0305 return self.__field_command.getvalue()
0306
0307 def __setfield_command(self, value):
0308 if isinstance(value,CSVSTRING):
0309 self.__field_command=value
0310 else:
0311 self.__field_command=CSVSTRING(value,**{'quotechar': None, 'terminator': ord(' '), 'constant': '+CXDR:'})
0312
0313 def __delfield_command(self): del self.__field_command
0314
0315 command=property(__getfield_command, __setfield_command, __delfield_command, None)
0316
0317 def __getfield_index(self):
0318 return self.__field_index.getvalue()
0319
0320 def __setfield_index(self, value):
0321 if isinstance(value,CSVINT):
0322 self.__field_index=value
0323 else:
0324 self.__field_index=CSVINT(value,)
0325
0326 def __delfield_index(self): del self.__field_index
0327
0328 index=property(__getfield_index, __setfield_index, __delfield_index, None)
0329
0330 def __getfield_repeat(self):
0331 return self.__field_repeat.getvalue()
0332
0333 def __setfield_repeat(self, value):
0334 if isinstance(value,CSVINT):
0335 self.__field_repeat=value
0336 else:
0337 self.__field_repeat=CSVINT(value,)
0338
0339 def __delfield_repeat(self): del self.__field_repeat
0340
0341 repeat=property(__getfield_repeat, __setfield_repeat, __delfield_repeat, None)
0342
0343 def __getfield_alarm(self):
0344 return self.__field_alarm.getvalue()
0345
0346 def __setfield_alarm(self, value):
0347 if isinstance(value,CSVINT):
0348 self.__field_alarm=value
0349 else:
0350 self.__field_alarm=CSVINT(value,)
0351
0352 def __delfield_alarm(self): del self.__field_alarm
0353
0354 alarm=property(__getfield_alarm, __setfield_alarm, __delfield_alarm, None)
0355
0356 def __getfield_date(self):
0357 return self.__field_date.getvalue()
0358
0359 def __setfield_date(self, value):
0360 if isinstance(value,GSMCALDATE):
0361 self.__field_date=value
0362 else:
0363 self.__field_date=GSMCALDATE(value,)
0364
0365 def __delfield_date(self): del self.__field_date
0366
0367 date=property(__getfield_date, __setfield_date, __delfield_date, None)
0368
0369 def __getfield_time(self):
0370 return self.__field_time.getvalue()
0371
0372 def __setfield_time(self, value):
0373 if isinstance(value,GSMCALTIME):
0374 self.__field_time=value
0375 else:
0376 self.__field_time=GSMCALTIME(value,)
0377
0378 def __delfield_time(self): del self.__field_time
0379
0380 time=property(__getfield_time, __setfield_time, __delfield_time, None)
0381
0382 def __getfield_description(self):
0383 return self.__field_description.getvalue()
0384
0385 def __setfield_description(self, value):
0386 if isinstance(value,CSVSTRING):
0387 self.__field_description=value
0388 else:
0389 self.__field_description=CSVSTRING(value,**{ 'terminator': None })
0390
0391 def __delfield_description(self): del self.__field_description
0392
0393 description=property(__getfield_description, __setfield_description, __delfield_description, None)
0394
0395 def iscontainer(self):
0396 return True
0397
0398 def containerelements(self):
0399 yield ('command', self.__field_command, None)
0400 yield ('index', self.__field_index, None)
0401 yield ('repeat', self.__field_repeat, None)
0402 yield ('alarm', self.__field_alarm, None)
0403 yield ('date', self.__field_date, None)
0404 yield ('time', self.__field_time, None)
0405 yield ('description', self.__field_description, None)
0406
0407
0408
0409
0410 class calendar_write_check_req(BaseProtogenClass):
0411 __fields=['command']
0412
0413 def __init__(self, *args, **kwargs):
0414 dict={}
0415 dict.update(kwargs)
0417 super(calendar_write_check_req,self).__init__(**dict)
0419 if self.__class__ is calendar_write_check_req:
0420 self._update(args,dict)
0421
0422
0423 def getfields(self):
0424 return self.__fields
0425
0426
0427 def _update(self, args, kwargs):
0428 super(calendar_write_check_req,self)._update(args,kwargs)
0429 keys=kwargs.keys()
0430 for key in keys:
0431 if key in self.__fields:
0432 setattr(self, key, kwargs[key])
0433 del kwargs[key]
0434 if __debug__:
0436 self._complainaboutunusedargs(calendar_write_check_req,kwargs)
0437 if len(args):
0438 dict2={ 'terminator': None, 'default': '+CXDW' }
0439 dict2.update(kwargs)
0440 kwargs=dict2
0441 self.__field_command=USTRING(*args,**dict2)
0442
0444
0445 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0446 'Writes this packet to the supplied buffer'
0447 self._bufferstartoffset=buf.getcurrentoffset()
0448 try: self.__field_command
0449 except:
0450 self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CXDW' })
0451 self.__field_command.writetobuffer(buf)
0452 self._bufferendoffset=buf.getcurrentoffset()
0453 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0454
0455
0456 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0457 'Reads this packet from the supplied buffer'
0458 self._bufferstartoffset=buf.getcurrentoffset()
0459 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0460 self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CXDW' })
0461 self.__field_command.readfrombuffer(buf)
0462 self._bufferendoffset=buf.getcurrentoffset()
0463
0464
0465 def __getfield_command(self):
0466 try: self.__field_command
0467 except:
0468 self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CXDW' })
0469 return self.__field_command.getvalue()
0470
0471 def __setfield_command(self, value):
0472 if isinstance(value,USTRING):
0473 self.__field_command=value
0474 else:
0475 self.__field_command=USTRING(value,**{ 'terminator': None, 'default': '+CXDW' })
0476
0477 def __delfield_command(self): del self.__field_command
0478
0479 command=property(__getfield_command, __setfield_command, __delfield_command, None)
0480
0481 def iscontainer(self):
0482 return True
0483
0484 def containerelements(self):
0485 yield ('command', self.__field_command, None)
0486
0487
0488
0489
0490 class calendar_write_check_resp(BaseProtogenClass):
0491 __fields=['command', 'index']
0492
0493 def __init__(self, *args, **kwargs):
0494 dict={}
0495 dict.update(kwargs)
0497 super(calendar_write_check_resp,self).__init__(**dict)
0499 if self.__class__ is calendar_write_check_resp:
0500 self._update(args,dict)
0501
0502
0503 def getfields(self):
0504 return self.__fields
0505
0506
0507 def _update(self, args, kwargs):
0508 super(calendar_write_check_resp,self)._update(args,kwargs)
0509 keys=kwargs.keys()
0510 for key in keys:
0511 if key in self.__fields:
0512 setattr(self, key, kwargs[key])
0513 del kwargs[key]
0514 if __debug__:
0516 self._complainaboutunusedargs(calendar_write_check_resp,kwargs)
0517 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0518
0520
0521 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0522 'Writes this packet to the supplied buffer'
0523 self._bufferstartoffset=buf.getcurrentoffset()
0524 self.__field_command.writetobuffer(buf)
0525 self.__field_index.writetobuffer(buf)
0526 self._bufferendoffset=buf.getcurrentoffset()
0527 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0528
0529
0530 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0531 'Reads this packet from the supplied buffer'
0532 self._bufferstartoffset=buf.getcurrentoffset()
0533 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0534 self.__field_command=USTRING(**{ 'terminator': ord(' '), 'constant': '+CXDW:' })
0535 self.__field_command.readfrombuffer(buf)
0536 self.__field_index=CSVINT(**{ 'terminator': None })
0537 self.__field_index.readfrombuffer(buf)
0538 self._bufferendoffset=buf.getcurrentoffset()
0539
0540
0541 def __getfield_command(self):
0542 return self.__field_command.getvalue()
0543
0544 def __setfield_command(self, value):
0545 if isinstance(value,USTRING):
0546 self.__field_command=value
0547 else:
0548 self.__field_command=USTRING(value,**{ 'terminator': ord(' '), 'constant': '+CXDW:' })
0549
0550 def __delfield_command(self): del self.__field_command
0551
0552 command=property(__getfield_command, __setfield_command, __delfield_command, None)
0553
0554 def __getfield_index(self):
0555 return self.__field_index.getvalue()
0556
0557 def __setfield_index(self, value):
0558 if isinstance(value,CSVINT):
0559 self.__field_index=value
0560 else:
0561 self.__field_index=CSVINT(value,**{ 'terminator': None })
0562
0563 def __delfield_index(self): del self.__field_index
0564
0565 index=property(__getfield_index, __setfield_index, __delfield_index, None)
0566
0567 def iscontainer(self):
0568 return True
0569
0570 def containerelements(self):
0571 yield ('command', self.__field_command, None)
0572 yield ('index', self.__field_index, None)
0573
0574
0575
0576
0577 class calendar_write_req(BaseProtogenClass):
0578 __fields=['command', 'index', 'repeat', 'alarm', 'date', 'time', 'description']
0579
0580 def __init__(self, *args, **kwargs):
0581 dict={}
0582 dict.update(kwargs)
0584 super(calendar_write_req,self).__init__(**dict)
0586 if self.__class__ is calendar_write_req:
0587 self._update(args,dict)
0588
0589
0590 def getfields(self):
0591 return self.__fields
0592
0593
0594 def _update(self, args, kwargs):
0595 super(calendar_write_req,self)._update(args,kwargs)
0596 keys=kwargs.keys()
0597 for key in keys:
0598 if key in self.__fields:
0599 setattr(self, key, kwargs[key])
0600 del kwargs[key]
0601 if __debug__:
0603 self._complainaboutunusedargs(calendar_write_req,kwargs)
0604 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0605
0607
0608 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0609 'Writes this packet to the supplied buffer'
0610 self._bufferstartoffset=buf.getcurrentoffset()
0611 try: self.__field_command
0612 except:
0613 self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CXDW=' })
0614 self.__field_command.writetobuffer(buf)
0615 try: self.__field_index
0616 except:
0617 self.__field_index=CSVINT()
0618 self.__field_index.writetobuffer(buf)
0619 try: self.__field_repeat
0620 except:
0621 self.__field_repeat=CSVINT()
0622 self.__field_repeat.writetobuffer(buf)
0623 try: self.__field_alarm
0624 except:
0625 self.__field_alarm=CSVINT()
0626 self.__field_alarm.writetobuffer(buf)
0627 try: self.__field_date
0628 except:
0629 self.__field_date=GSMCALDATE()
0630 self.__field_date.writetobuffer(buf)
0631 try: self.__field_time
0632 except:
0633 self.__field_time=GSMCALTIME()
0634 self.__field_time.writetobuffer(buf)
0635 try: self.__field_description
0636 except:
0637 self.__field_description=CSVSTRING(**{ 'terminator': None, 'maxsizeinbytes': CAL_DESC_LEN, 'raiseontruncate': False })
0638 self.__field_description.writetobuffer(buf)
0639 self._bufferendoffset=buf.getcurrentoffset()
0640 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0641
0642
0643 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0644 'Reads this packet from the supplied buffer'
0645 self._bufferstartoffset=buf.getcurrentoffset()
0646 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0647 self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CXDW=' })
0648 self.__field_command.readfrombuffer(buf)
0649 self.__field_index=CSVINT()
0650 self.__field_index.readfrombuffer(buf)
0651 self.__field_repeat=CSVINT()
0652 self.__field_repeat.readfrombuffer(buf)
0653 self.__field_alarm=CSVINT()
0654 self.__field_alarm.readfrombuffer(buf)
0655 self.__field_date=GSMCALDATE()
0656 self.__field_date.readfrombuffer(buf)
0657 self.__field_time=GSMCALTIME()
0658 self.__field_time.readfrombuffer(buf)
0659 self.__field_description=CSVSTRING(**{ 'terminator': None, 'maxsizeinbytes': CAL_DESC_LEN, 'raiseontruncate': False })
0660 self.__field_description.readfrombuffer(buf)
0661 self._bufferendoffset=buf.getcurrentoffset()
0662
0663
0664 def __getfield_command(self):
0665 try: self.__field_command
0666 except:
0667 self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CXDW=' })
0668 return self.__field_command.getvalue()
0669
0670 def __setfield_command(self, value):
0671 if isinstance(value,USTRING):
0672 self.__field_command=value
0673 else:
0674 self.__field_command=USTRING(value,**{ 'terminator': None, 'default': '+CXDW=' })
0675
0676 def __delfield_command(self): del self.__field_command
0677
0678 command=property(__getfield_command, __setfield_command, __delfield_command, None)
0679
0680 def __getfield_index(self):
0681 try: self.__field_index
0682 except:
0683 self.__field_index=CSVINT()
0684 return self.__field_index.getvalue()
0685
0686 def __setfield_index(self, value):
0687 if isinstance(value,CSVINT):
0688 self.__field_index=value
0689 else:
0690 self.__field_index=CSVINT(value,)
0691
0692 def __delfield_index(self): del self.__field_index
0693
0694 index=property(__getfield_index, __setfield_index, __delfield_index, None)
0695
0696 def __getfield_repeat(self):
0697 try: self.__field_repeat
0698 except:
0699 self.__field_repeat=CSVINT()
0700 return self.__field_repeat.getvalue()
0701
0702 def __setfield_repeat(self, value):
0703 if isinstance(value,CSVINT):
0704 self.__field_repeat=value
0705 else:
0706 self.__field_repeat=CSVINT(value,)
0707
0708 def __delfield_repeat(self): del self.__field_repeat
0709
0710 repeat=property(__getfield_repeat, __setfield_repeat, __delfield_repeat, None)
0711
0712 def __getfield_alarm(self):
0713 try: self.__field_alarm
0714 except:
0715 self.__field_alarm=CSVINT()
0716 return self.__field_alarm.getvalue()
0717
0718 def __setfield_alarm(self, value):
0719 if isinstance(value,CSVINT):
0720 self.__field_alarm=value
0721 else:
0722 self.__field_alarm=CSVINT(value,)
0723
0724 def __delfield_alarm(self): del self.__field_alarm
0725
0726 alarm=property(__getfield_alarm, __setfield_alarm, __delfield_alarm, None)
0727
0728 def __getfield_date(self):
0729 try: self.__field_date
0730 except:
0731 self.__field_date=GSMCALDATE()
0732 return self.__field_date.getvalue()
0733
0734 def __setfield_date(self, value):
0735 if isinstance(value,GSMCALDATE):
0736 self.__field_date=value
0737 else:
0738 self.__field_date=GSMCALDATE(value,)
0739
0740 def __delfield_date(self): del self.__field_date
0741
0742 date=property(__getfield_date, __setfield_date, __delfield_date, None)
0743
0744 def __getfield_time(self):
0745 try: self.__field_time
0746 except:
0747 self.__field_time=GSMCALTIME()
0748 return self.__field_time.getvalue()
0749
0750 def __setfield_time(self, value):
0751 if isinstance(value,GSMCALTIME):
0752 self.__field_time=value
0753 else:
0754 self.__field_time=GSMCALTIME(value,)
0755
0756 def __delfield_time(self): del self.__field_time
0757
0758 time=property(__getfield_time, __setfield_time, __delfield_time, None)
0759
0760 def __getfield_description(self):
0761 try: self.__field_description
0762 except:
0763 self.__field_description=CSVSTRING(**{ 'terminator': None, 'maxsizeinbytes': CAL_DESC_LEN, 'raiseontruncate': False })
0764 return self.__field_description.getvalue()
0765
0766 def __setfield_description(self, value):
0767 if isinstance(value,CSVSTRING):
0768 self.__field_description=value
0769 else:
0770 self.__field_description=CSVSTRING(value,**{ 'terminator': None, 'maxsizeinbytes': CAL_DESC_LEN, 'raiseontruncate': False })
0771
0772 def __delfield_description(self): del self.__field_description
0773
0774 description=property(__getfield_description, __setfield_description, __delfield_description, None)
0775
0776 def iscontainer(self):
0777 return True
0778
0779 def containerelements(self):
0780 yield ('command', self.__field_command, None)
0781 yield ('index', self.__field_index, None)
0782 yield ('repeat', self.__field_repeat, None)
0783 yield ('alarm', self.__field_alarm, None)
0784 yield ('date', self.__field_date, None)
0785 yield ('time', self.__field_time, None)
0786 yield ('description', self.__field_description, None)
0787
0788
0789
0790
0791 class calendar_del_req(BaseProtogenClass):
0792 __fields=['command', 'index']
0793
0794 def __init__(self, *args, **kwargs):
0795 dict={}
0796 dict.update(kwargs)
0798 super(calendar_del_req,self).__init__(**dict)
0800 if self.__class__ is calendar_del_req:
0801 self._update(args,dict)
0802
0803
0804 def getfields(self):
0805 return self.__fields
0806
0807
0808 def _update(self, args, kwargs):
0809 super(calendar_del_req,self)._update(args,kwargs)
0810 keys=kwargs.keys()
0811 for key in keys:
0812 if key in self.__fields:
0813 setattr(self, key, kwargs[key])
0814 del kwargs[key]
0815 if __debug__:
0817 self._complainaboutunusedargs(calendar_del_req,kwargs)
0818 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0819
0821
0822 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0823 'Writes this packet to the supplied buffer'
0824 self._bufferstartoffset=buf.getcurrentoffset()
0825 try: self.__field_command
0826 except:
0827 self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CXDW=' })
0828 self.__field_command.writetobuffer(buf)
0829 try: self.__field_index
0830 except:
0831 self.__field_index=CSVINT(**{ 'terminator': None })
0832 self.__field_index.writetobuffer(buf)
0833 self._bufferendoffset=buf.getcurrentoffset()
0834 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0835
0836
0837 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0838 'Reads this packet from the supplied buffer'
0839 self._bufferstartoffset=buf.getcurrentoffset()
0840 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0841 self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CXDW=' })
0842 self.__field_command.readfrombuffer(buf)
0843 self.__field_index=CSVINT(**{ 'terminator': None })
0844 self.__field_index.readfrombuffer(buf)
0845 self._bufferendoffset=buf.getcurrentoffset()
0846
0847
0848 def __getfield_command(self):
0849 try: self.__field_command
0850 except:
0851 self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CXDW=' })
0852 return self.__field_command.getvalue()
0853
0854 def __setfield_command(self, value):
0855 if isinstance(value,USTRING):
0856 self.__field_command=value
0857 else:
0858 self.__field_command=USTRING(value,**{ 'terminator': None, 'default': '+CXDW=' })
0859
0860 def __delfield_command(self): del self.__field_command
0861
0862 command=property(__getfield_command, __setfield_command, __delfield_command, None)
0863
0864 def __getfield_index(self):
0865 try: self.__field_index
0866 except:
0867 self.__field_index=CSVINT(**{ 'terminator': None })
0868 return self.__field_index.getvalue()
0869
0870 def __setfield_index(self, value):
0871 if isinstance(value,CSVINT):
0872 self.__field_index=value
0873 else:
0874 self.__field_index=CSVINT(value,**{ 'terminator': None })
0875
0876 def __delfield_index(self): del self.__field_index
0877
0878 index=property(__getfield_index, __setfield_index, __delfield_index, None)
0879
0880 def iscontainer(self):
0881 return True
0882
0883 def containerelements(self):
0884 yield ('command', self.__field_command, None)
0885 yield ('index', self.__field_index, None)
0886
0887
0888
0889
0890 class media_selector_req(BaseProtogenClass):
0891 __fields=['command']
0892
0893 def __init__(self, *args, **kwargs):
0894 dict={}
0895 dict.update(kwargs)
0897 super(media_selector_req,self).__init__(**dict)
0899 if self.__class__ is media_selector_req:
0900 self._update(args,dict)
0901
0902
0903 def getfields(self):
0904 return self.__fields
0905
0906
0907 def _update(self, args, kwargs):
0908 super(media_selector_req,self)._update(args,kwargs)
0909 keys=kwargs.keys()
0910 for key in keys:
0911 if key in self.__fields:
0912 setattr(self, key, kwargs[key])
0913 del kwargs[key]
0914 if __debug__:
0916 self._complainaboutunusedargs(media_selector_req,kwargs)
0917 if len(args):
0918 dict2={ 'terminator': None, 'default': '+DDLS?' }
0919 dict2.update(kwargs)
0920 kwargs=dict2
0921 self.__field_command=USTRING(*args,**dict2)
0922
0924
0925 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0926 'Writes this packet to the supplied buffer'
0927 self._bufferstartoffset=buf.getcurrentoffset()
0928 try: self.__field_command
0929 except:
0930 self.__field_command=USTRING(**{ 'terminator': None, 'default': '+DDLS?' })
0931 self.__field_command.writetobuffer(buf)
0932 self._bufferendoffset=buf.getcurrentoffset()
0933 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0934
0935
0936 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0937 'Reads this packet from the supplied buffer'
0938 self._bufferstartoffset=buf.getcurrentoffset()
0939 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0940 self.__field_command=USTRING(**{ 'terminator': None, 'default': '+DDLS?' })
0941 self.__field_command.readfrombuffer(buf)
0942 self._bufferendoffset=buf.getcurrentoffset()
0943
0944
0945 def __getfield_command(self):
0946 try: self.__field_command
0947 except:
0948 self.__field_command=USTRING(**{ 'terminator': None, 'default': '+DDLS?' })
0949 return self.__field_command.getvalue()
0950
0951 def __setfield_command(self, value):
0952 if isinstance(value,USTRING):
0953 self.__field_command=value
0954 else:
0955 self.__field_command=USTRING(value,**{ 'terminator': None, 'default': '+DDLS?' })
0956
0957 def __delfield_command(self): del self.__field_command
0958
0959 command=property(__getfield_command, __setfield_command, __delfield_command, None)
0960
0961 def iscontainer(self):
0962 return True
0963
0964 def containerelements(self):
0965 yield ('command', self.__field_command, None)
0966
0967
0968
0969
0970 class media_selector_resp(BaseProtogenClass):
0971 __fields=['command', 'media_type']
0972
0973 def __init__(self, *args, **kwargs):
0974 dict={}
0975 dict.update(kwargs)
0977 super(media_selector_resp,self).__init__(**dict)
0979 if self.__class__ is media_selector_resp:
0980 self._update(args,dict)
0981
0982
0983 def getfields(self):
0984 return self.__fields
0985
0986
0987 def _update(self, args, kwargs):
0988 super(media_selector_resp,self)._update(args,kwargs)
0989 keys=kwargs.keys()
0990 for key in keys:
0991 if key in self.__fields:
0992 setattr(self, key, kwargs[key])
0993 del kwargs[key]
0994 if __debug__:
0996 self._complainaboutunusedargs(media_selector_resp,kwargs)
0997 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0998
1000
1001 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1002 'Writes this packet to the supplied buffer'
1003 self._bufferstartoffset=buf.getcurrentoffset()
1004 self.__field_command.writetobuffer(buf)
1005 self.__field_media_type.writetobuffer(buf)
1006 self._bufferendoffset=buf.getcurrentoffset()
1007 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1008
1009
1010 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1011 'Reads this packet from the supplied buffer'
1012 self._bufferstartoffset=buf.getcurrentoffset()
1013 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1014 self.__field_command=USTRING(**{ 'terminator': ord(' '), 'constant': '+DDLS:' })
1015 self.__field_command.readfrombuffer(buf)
1016 self.__field_media_type=CSVINT(**{ 'terminator': None })
1017 self.__field_media_type.readfrombuffer(buf)
1018 self._bufferendoffset=buf.getcurrentoffset()
1019
1020
1021 def __getfield_command(self):
1022 return self.__field_command.getvalue()
1023
1024 def __setfield_command(self, value):
1025 if isinstance(value,USTRING):
1026 self.__field_command=value
1027 else:
1028 self.__field_command=USTRING(value,**{ 'terminator': ord(' '), 'constant': '+DDLS:' })
1029
1030 def __delfield_command(self): del self.__field_command
1031
1032 command=property(__getfield_command, __setfield_command, __delfield_command, None)
1033
1034 def __getfield_media_type(self):
1035 return self.__field_media_type.getvalue()
1036
1037 def __setfield_media_type(self, value):
1038 if isinstance(value,CSVINT):
1039 self.__field_media_type=value
1040 else:
1041 self.__field_media_type=CSVINT(value,**{ 'terminator': None })
1042
1043 def __delfield_media_type(self): del self.__field_media_type
1044
1045 media_type=property(__getfield_media_type, __setfield_media_type, __delfield_media_type, None)
1046
1047 def iscontainer(self):
1048 return True
1049
1050 def containerelements(self):
1051 yield ('command', self.__field_command, None)
1052 yield ('media_type', self.__field_media_type, None)
1053
1054
1055
1056
1057 class media_selector_set(BaseProtogenClass):
1058 __fields=['command', 'media_type']
1059
1060 def __init__(self, *args, **kwargs):
1061 dict={}
1062 dict.update(kwargs)
1064 super(media_selector_set,self).__init__(**dict)
1066 if self.__class__ is media_selector_set:
1067 self._update(args,dict)
1068
1069
1070 def getfields(self):
1071 return self.__fields
1072
1073
1074 def _update(self, args, kwargs):
1075 super(media_selector_set,self)._update(args,kwargs)
1076 keys=kwargs.keys()
1077 for key in keys:
1078 if key in self.__fields:
1079 setattr(self, key, kwargs[key])
1080 del kwargs[key]
1081 if __debug__:
1083 self._complainaboutunusedargs(media_selector_set,kwargs)
1084 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1085
1087
1088 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1089 'Writes this packet to the supplied buffer'
1090 self._bufferstartoffset=buf.getcurrentoffset()
1091 try: self.__field_command
1092 except:
1093 self.__field_command=USTRING(**{ 'terminator': None, 'default': '+DDLS=' })
1094 self.__field_command.writetobuffer(buf)
1095 try: self.__field_media_type
1096 except:
1097 self.__field_media_type=CSVINT(**{ 'terminator': None })
1098 self.__field_media_type.writetobuffer(buf)
1099 self._bufferendoffset=buf.getcurrentoffset()
1100 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1101
1102
1103 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1104 'Reads this packet from the supplied buffer'
1105 self._bufferstartoffset=buf.getcurrentoffset()
1106 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1107 self.__field_command=USTRING(**{ 'terminator': None, 'default': '+DDLS=' })
1108 self.__field_command.readfrombuffer(buf)
1109 self.__field_media_type=CSVINT(**{ 'terminator': None })
1110 self.__field_media_type.readfrombuffer(buf)
1111 self._bufferendoffset=buf.getcurrentoffset()
1112
1113
1114 def __getfield_command(self):
1115 try: self.__field_command
1116 except:
1117 self.__field_command=USTRING(**{ 'terminator': None, 'default': '+DDLS=' })
1118 return self.__field_command.getvalue()
1119
1120 def __setfield_command(self, value):
1121 if isinstance(value,USTRING):
1122 self.__field_command=value
1123 else:
1124 self.__field_command=USTRING(value,**{ 'terminator': None, 'default': '+DDLS=' })
1125
1126 def __delfield_command(self): del self.__field_command
1127
1128 command=property(__getfield_command, __setfield_command, __delfield_command, None)
1129
1130 def __getfield_media_type(self):
1131 try: self.__field_media_type
1132 except:
1133 self.__field_media_type=CSVINT(**{ 'terminator': None })
1134 return self.__field_media_type.getvalue()
1135
1136 def __setfield_media_type(self, value):
1137 if isinstance(value,CSVINT):
1138 self.__field_media_type=value
1139 else:
1140 self.__field_media_type=CSVINT(value,**{ 'terminator': None })
1141
1142 def __delfield_media_type(self): del self.__field_media_type
1143
1144 media_type=property(__getfield_media_type, __setfield_media_type, __delfield_media_type, None)
1145
1146 def iscontainer(self):
1147 return True
1148
1149 def containerelements(self):
1150 yield ('command', self.__field_command, None)
1151 yield ('media_type', self.__field_media_type, None)
1152
1153
1154
1155
1156 class media_list_req(BaseProtogenClass):
1157 __fields=['command', 'start_index', 'end_index']
1158
1159 def __init__(self, *args, **kwargs):
1160 dict={}
1161 dict.update(kwargs)
1163 super(media_list_req,self).__init__(**dict)
1165 if self.__class__ is media_list_req:
1166 self._update(args,dict)
1167
1168
1169 def getfields(self):
1170 return self.__fields
1171
1172
1173 def _update(self, args, kwargs):
1174 super(media_list_req,self)._update(args,kwargs)
1175 keys=kwargs.keys()
1176 for key in keys:
1177 if key in self.__fields:
1178 setattr(self, key, kwargs[key])
1179 del kwargs[key]
1180 if __debug__:
1182 self._complainaboutunusedargs(media_list_req,kwargs)
1183 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1184
1186
1187 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1188 'Writes this packet to the supplied buffer'
1189 self._bufferstartoffset=buf.getcurrentoffset()
1190 try: self.__field_command
1191 except:
1192 self.__field_command=USTRING(**{ 'terminator': None, 'default': '+DDLR=' })
1193 self.__field_command.writetobuffer(buf)
1194 try: self.__field_start_index
1195 except:
1196 self.__field_start_index=CSVINT()
1197 self.__field_start_index.writetobuffer(buf)
1198 try: self.__field_end_index
1199 except:
1200 self.__field_end_index=CSVINT(**{ 'terminator': None })
1201 self.__field_end_index.writetobuffer(buf)
1202 self._bufferendoffset=buf.getcurrentoffset()
1203 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1204
1205
1206 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1207 'Reads this packet from the supplied buffer'
1208 self._bufferstartoffset=buf.getcurrentoffset()
1209 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1210 self.__field_command=USTRING(**{ 'terminator': None, 'default': '+DDLR=' })
1211 self.__field_command.readfrombuffer(buf)
1212 self.__field_start_index=CSVINT()
1213 self.__field_start_index.readfrombuffer(buf)
1214 self.__field_end_index=CSVINT(**{ 'terminator': None })
1215 self.__field_end_index.readfrombuffer(buf)
1216 self._bufferendoffset=buf.getcurrentoffset()
1217
1218
1219 def __getfield_command(self):
1220 try: self.__field_command
1221 except:
1222 self.__field_command=USTRING(**{ 'terminator': None, 'default': '+DDLR=' })
1223 return self.__field_command.getvalue()
1224
1225 def __setfield_command(self, value):
1226 if isinstance(value,USTRING):
1227 self.__field_command=value
1228 else:
1229 self.__field_command=USTRING(value,**{ 'terminator': None, 'default': '+DDLR=' })
1230
1231 def __delfield_command(self): del self.__field_command
1232
1233 command=property(__getfield_command, __setfield_command, __delfield_command, None)
1234
1235 def __getfield_start_index(self):
1236 try: self.__field_start_index
1237 except:
1238 self.__field_start_index=CSVINT()
1239 return self.__field_start_index.getvalue()
1240
1241 def __setfield_start_index(self, value):
1242 if isinstance(value,CSVINT):
1243 self.__field_start_index=value
1244 else:
1245 self.__field_start_index=CSVINT(value,)
1246
1247 def __delfield_start_index(self): del self.__field_start_index
1248
1249 start_index=property(__getfield_start_index, __setfield_start_index, __delfield_start_index, None)
1250
1251 def __getfield_end_index(self):
1252 try: self.__field_end_index
1253 except:
1254 self.__field_end_index=CSVINT(**{ 'terminator': None })
1255 return self.__field_end_index.getvalue()
1256
1257 def __setfield_end_index(self, value):
1258 if isinstance(value,CSVINT):
1259 self.__field_end_index=value
1260 else:
1261 self.__field_end_index=CSVINT(value,**{ 'terminator': None })
1262
1263 def __delfield_end_index(self): del self.__field_end_index
1264
1265 end_index=property(__getfield_end_index, __setfield_end_index, __delfield_end_index, None)
1266
1267 def iscontainer(self):
1268 return True
1269
1270 def containerelements(self):
1271 yield ('command', self.__field_command, None)
1272 yield ('start_index', self.__field_start_index, None)
1273 yield ('end_index', self.__field_end_index, None)
1274
1275
1276
1277
1278 class media_list_resp(BaseProtogenClass):
1279 __fields=['command', 'index', 'file_name', 'media_name', 'size']
1280
1281 def __init__(self, *args, **kwargs):
1282 dict={}
1283 dict.update(kwargs)
1285 super(media_list_resp,self).__init__(**dict)
1287 if self.__class__ is media_list_resp:
1288 self._update(args,dict)
1289
1290
1291 def getfields(self):
1292 return self.__fields
1293
1294
1295 def _update(self, args, kwargs):
1296 super(media_list_resp,self)._update(args,kwargs)
1297 keys=kwargs.keys()
1298 for key in keys:
1299 if key in self.__fields:
1300 setattr(self, key, kwargs[key])
1301 del kwargs[key]
1302 if __debug__:
1304 self._complainaboutunusedargs(media_list_resp,kwargs)
1305 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1306
1308
1309 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1310 'Writes this packet to the supplied buffer'
1311 self._bufferstartoffset=buf.getcurrentoffset()
1312 self.__field_command.writetobuffer(buf)
1313 self.__field_index.writetobuffer(buf)
1314 self.__field_file_name.writetobuffer(buf)
1315 self.__field_media_name.writetobuffer(buf)
1316 self.__field_size.writetobuffer(buf)
1317 self._bufferendoffset=buf.getcurrentoffset()
1318 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1319
1320
1321 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1322 'Reads this packet from the supplied buffer'
1323 self._bufferstartoffset=buf.getcurrentoffset()
1324 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1325 self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': ord(' '), 'constant': '+DDLR:'})
1326 self.__field_command.readfrombuffer(buf)
1327 self.__field_index=CSVINT()
1328 self.__field_index.readfrombuffer(buf)
1329 self.__field_file_name=CSVSTRING()
1330 self.__field_file_name.readfrombuffer(buf)
1331 self.__field_media_name=CSVSTRING()
1332 self.__field_media_name.readfrombuffer(buf)
1333 self.__field_size=CSVINT()
1334 self.__field_size.readfrombuffer(buf)
1335 self._bufferendoffset=buf.getcurrentoffset()
1336
1337
1338 def __getfield_command(self):
1339 return self.__field_command.getvalue()
1340
1341 def __setfield_command(self, value):
1342 if isinstance(value,CSVSTRING):
1343 self.__field_command=value
1344 else:
1345 self.__field_command=CSVSTRING(value,**{'quotechar': None, 'terminator': ord(' '), 'constant': '+DDLR:'})
1346
1347 def __delfield_command(self): del self.__field_command
1348
1349 command=property(__getfield_command, __setfield_command, __delfield_command, None)
1350
1351 def __getfield_index(self):
1352 return self.__field_index.getvalue()
1353
1354 def __setfield_index(self, value):
1355 if isinstance(value,CSVINT):
1356 self.__field_index=value
1357 else:
1358 self.__field_index=CSVINT(value,)
1359
1360 def __delfield_index(self): del self.__field_index
1361
1362 index=property(__getfield_index, __setfield_index, __delfield_index, None)
1363
1364 def __getfield_file_name(self):
1365 return self.__field_file_name.getvalue()
1366
1367 def __setfield_file_name(self, value):
1368 if isinstance(value,CSVSTRING):
1369 self.__field_file_name=value
1370 else:
1371 self.__field_file_name=CSVSTRING(value,)
1372
1373 def __delfield_file_name(self): del self.__field_file_name
1374
1375 file_name=property(__getfield_file_name, __setfield_file_name, __delfield_file_name, None)
1376
1377 def __getfield_media_name(self):
1378 return self.__field_media_name.getvalue()
1379
1380 def __setfield_media_name(self, value):
1381 if isinstance(value,CSVSTRING):
1382 self.__field_media_name=value
1383 else:
1384 self.__field_media_name=CSVSTRING(value,)
1385
1386 def __delfield_media_name(self): del self.__field_media_name
1387
1388 media_name=property(__getfield_media_name, __setfield_media_name, __delfield_media_name, None)
1389
1390 def __getfield_size(self):
1391 return self.__field_size.getvalue()
1392
1393 def __setfield_size(self, value):
1394 if isinstance(value,CSVINT):
1395 self.__field_size=value
1396 else:
1397 self.__field_size=CSVINT(value,)
1398
1399 def __delfield_size(self): del self.__field_size
1400
1401 size=property(__getfield_size, __setfield_size, __delfield_size, None)
1402
1403 def iscontainer(self):
1404 return True
1405
1406 def containerelements(self):
1407 yield ('command', self.__field_command, None)
1408 yield ('index', self.__field_index, None)
1409 yield ('file_name', self.__field_file_name, None)
1410 yield ('media_name', self.__field_media_name, None)
1411 yield ('size', self.__field_size, None)
1412
1413
1414
1415
1416 class del_media_req(BaseProtogenClass):
1417 __fields=['command', 'file_name']
1418
1419 def __init__(self, *args, **kwargs):
1420 dict={}
1421 dict.update(kwargs)
1423 super(del_media_req,self).__init__(**dict)
1425 if self.__class__ is del_media_req:
1426 self._update(args,dict)
1427
1428
1429 def getfields(self):
1430 return self.__fields
1431
1432
1433 def _update(self, args, kwargs):
1434 super(del_media_req,self)._update(args,kwargs)
1435 keys=kwargs.keys()
1436 for key in keys:
1437 if key in self.__fields:
1438 setattr(self, key, kwargs[key])
1439 del kwargs[key]
1440 if __debug__:
1442 self._complainaboutunusedargs(del_media_req,kwargs)
1443 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1444
1446
1447 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1448 'Writes this packet to the supplied buffer'
1449 self._bufferstartoffset=buf.getcurrentoffset()
1450 try: self.__field_command
1451 except:
1452 self.__field_command=USTRING(**{ 'terminator': None, 'default': '+DDLD=0,' })
1453 self.__field_command.writetobuffer(buf)
1454 try: self.__field_file_name
1455 except:
1456 self.__field_file_name=CSVSTRING(**{ 'terminator': None })
1457 self.__field_file_name.writetobuffer(buf)
1458 self._bufferendoffset=buf.getcurrentoffset()
1459 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1460
1461
1462 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1463 'Reads this packet from the supplied buffer'
1464 self._bufferstartoffset=buf.getcurrentoffset()
1465 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1466 self.__field_command=USTRING(**{ 'terminator': None, 'default': '+DDLD=0,' })
1467 self.__field_command.readfrombuffer(buf)
1468 self.__field_file_name=CSVSTRING(**{ 'terminator': None })
1469 self.__field_file_name.readfrombuffer(buf)
1470 self._bufferendoffset=buf.getcurrentoffset()
1471
1472
1473 def __getfield_command(self):
1474 try: self.__field_command
1475 except:
1476 self.__field_command=USTRING(**{ 'terminator': None, 'default': '+DDLD=0,' })
1477 return self.__field_command.getvalue()
1478
1479 def __setfield_command(self, value):
1480 if isinstance(value,USTRING):
1481 self.__field_command=value
1482 else:
1483 self.__field_command=USTRING(value,**{ 'terminator': None, 'default': '+DDLD=0,' })
1484
1485 def __delfield_command(self): del self.__field_command
1486
1487 command=property(__getfield_command, __setfield_command, __delfield_command, None)
1488
1489 def __getfield_file_name(self):
1490 try: self.__field_file_name
1491 except:
1492 self.__field_file_name=CSVSTRING(**{ 'terminator': None })
1493 return self.__field_file_name.getvalue()
1494
1495 def __setfield_file_name(self, value):
1496 if isinstance(value,CSVSTRING):
1497 self.__field_file_name=value
1498 else:
1499 self.__field_file_name=CSVSTRING(value,**{ 'terminator': None })
1500
1501 def __delfield_file_name(self): del self.__field_file_name
1502
1503 file_name=property(__getfield_file_name, __setfield_file_name, __delfield_file_name, None)
1504
1505 def iscontainer(self):
1506 return True
1507
1508 def containerelements(self):
1509 yield ('command', self.__field_command, None)
1510 yield ('file_name', self.__field_file_name, None)
1511
1512
1513
1514
1515 class write_media_req(BaseProtogenClass):
1516 __fields=['command', 'index', 'file_name', 'media_name', 'data_len', 'media_type', 'dunno1', 'dunno2', 'dunno3', 'dunno4']
1517
1518 def __init__(self, *args, **kwargs):
1519 dict={}
1520 dict.update(kwargs)
1522 super(write_media_req,self).__init__(**dict)
1524 if self.__class__ is write_media_req:
1525 self._update(args,dict)
1526
1527
1528 def getfields(self):
1529 return self.__fields
1530
1531
1532 def _update(self, args, kwargs):
1533 super(write_media_req,self)._update(args,kwargs)
1534 keys=kwargs.keys()
1535 for key in keys:
1536 if key in self.__fields:
1537 setattr(self, key, kwargs[key])
1538 del kwargs[key]
1539 if __debug__:
1541 self._complainaboutunusedargs(write_media_req,kwargs)
1542 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1543
1545
1546 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1547 'Writes this packet to the supplied buffer'
1548 self._bufferstartoffset=buf.getcurrentoffset()
1549 try: self.__field_command
1550 except:
1551 self.__field_command=USTRING(**{ 'terminator': None, 'default': '+DDLW=' })
1552 self.__field_command.writetobuffer(buf)
1553 try: self.__field_index
1554 except:
1555 self.__field_index=CSVINT()
1556 self.__field_index.writetobuffer(buf)
1557 try: self.__field_file_name
1558 except:
1559 self.__field_file_name=CSVSTRING()
1560 self.__field_file_name.writetobuffer(buf)
1561 try: self.__field_media_name
1562 except:
1563 self.__field_media_name=CSVSTRING()
1564 self.__field_media_name.writetobuffer(buf)
1565 self.__field_data_len.writetobuffer(buf)
1566 self.__field_media_type.writetobuffer(buf)
1567 try: self.__field_dunno1
1568 except:
1569 self.__field_dunno1=CSVINT(**{ 'default': 0 })
1570 self.__field_dunno1.writetobuffer(buf)
1571 try: self.__field_dunno2
1572 except:
1573 self.__field_dunno2=CSVINT(**{ 'default': 0 })
1574 self.__field_dunno2.writetobuffer(buf)
1575 try: self.__field_dunno3
1576 except:
1577 self.__field_dunno3=CSVINT(**{ 'default': 0 })
1578 self.__field_dunno3.writetobuffer(buf)
1579 try: self.__field_dunno4
1580 except:
1581 self.__field_dunno4=CSVINT(**{ 'default': 0, 'terminator': ord('\r') })
1582 self.__field_dunno4.writetobuffer(buf)
1583 self._bufferendoffset=buf.getcurrentoffset()
1584 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1585
1586
1587 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1588 'Reads this packet from the supplied buffer'
1589 self._bufferstartoffset=buf.getcurrentoffset()
1590 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1591 self.__field_command=USTRING(**{ 'terminator': None, 'default': '+DDLW=' })
1592 self.__field_command.readfrombuffer(buf)
1593 self.__field_index=CSVINT()
1594 self.__field_index.readfrombuffer(buf)
1595 self.__field_file_name=CSVSTRING()
1596 self.__field_file_name.readfrombuffer(buf)
1597 self.__field_media_name=CSVSTRING()
1598 self.__field_media_name.readfrombuffer(buf)
1599 self.__field_data_len=CSVINT()
1600 self.__field_data_len.readfrombuffer(buf)
1601 self.__field_media_type=CSVINT()
1602 self.__field_media_type.readfrombuffer(buf)
1603 self.__field_dunno1=CSVINT(**{ 'default': 0 })
1604 self.__field_dunno1.readfrombuffer(buf)
1605 self.__field_dunno2=CSVINT(**{ 'default': 0 })
1606 self.__field_dunno2.readfrombuffer(buf)
1607 self.__field_dunno3=CSVINT(**{ 'default': 0 })
1608 self.__field_dunno3.readfrombuffer(buf)
1609 self.__field_dunno4=CSVINT(**{ 'default': 0, 'terminator': ord('\r') })
1610 self.__field_dunno4.readfrombuffer(buf)
1611 self._bufferendoffset=buf.getcurrentoffset()
1612
1613
1614 def __getfield_command(self):
1615 try: self.__field_command
1616 except:
1617 self.__field_command=USTRING(**{ 'terminator': None, 'default': '+DDLW=' })
1618 return self.__field_command.getvalue()
1619
1620 def __setfield_command(self, value):
1621 if isinstance(value,USTRING):
1622 self.__field_command=value
1623 else:
1624 self.__field_command=USTRING(value,**{ 'terminator': None, 'default': '+DDLW=' })
1625
1626 def __delfield_command(self): del self.__field_command
1627
1628 command=property(__getfield_command, __setfield_command, __delfield_command, None)
1629
1630 def __getfield_index(self):
1631 try: self.__field_index
1632 except:
1633 self.__field_index=CSVINT()
1634 return self.__field_index.getvalue()
1635
1636 def __setfield_index(self, value):
1637 if isinstance(value,CSVINT):
1638 self.__field_index=value
1639 else:
1640 self.__field_index=CSVINT(value,)
1641
1642 def __delfield_index(self): del self.__field_index
1643
1644 index=property(__getfield_index, __setfield_index, __delfield_index, None)
1645
1646 def __getfield_file_name(self):
1647 try: self.__field_file_name
1648 except:
1649 self.__field_file_name=CSVSTRING()
1650 return self.__field_file_name.getvalue()
1651
1652 def __setfield_file_name(self, value):
1653 if isinstance(value,CSVSTRING):
1654 self.__field_file_name=value
1655 else:
1656 self.__field_file_name=CSVSTRING(value,)
1657
1658 def __delfield_file_name(self): del self.__field_file_name
1659
1660 file_name=property(__getfield_file_name, __setfield_file_name, __delfield_file_name, None)
1661
1662 def __getfield_media_name(self):
1663 try: self.__field_media_name
1664 except:
1665 self.__field_media_name=CSVSTRING()
1666 return self.__field_media_name.getvalue()
1667
1668 def __setfield_media_name(self, value):
1669 if isinstance(value,CSVSTRING):
1670 self.__field_media_name=value
1671 else:
1672 self.__field_media_name=CSVSTRING(value,)
1673
1674 def __delfield_media_name(self): del self.__field_media_name
1675
1676 media_name=property(__getfield_media_name, __setfield_media_name, __delfield_media_name, None)
1677
1678 def __getfield_data_len(self):
1679 return self.__field_data_len.getvalue()
1680
1681 def __setfield_data_len(self, value):
1682 if isinstance(value,CSVINT):
1683 self.__field_data_len=value
1684 else:
1685 self.__field_data_len=CSVINT(value,)
1686
1687 def __delfield_data_len(self): del self.__field_data_len
1688
1689 data_len=property(__getfield_data_len, __setfield_data_len, __delfield_data_len, None)
1690
1691 def __getfield_media_type(self):
1692 return self.__field_media_type.getvalue()
1693
1694 def __setfield_media_type(self, value):
1695 if isinstance(value,CSVINT):
1696 self.__field_media_type=value
1697 else:
1698 self.__field_media_type=CSVINT(value,)
1699
1700 def __delfield_media_type(self): del self.__field_media_type
1701
1702 media_type=property(__getfield_media_type, __setfield_media_type, __delfield_media_type, None)
1703
1704 def __getfield_dunno1(self):
1705 try: self.__field_dunno1
1706 except:
1707 self.__field_dunno1=CSVINT(**{ 'default': 0 })
1708 return self.__field_dunno1.getvalue()
1709
1710 def __setfield_dunno1(self, value):
1711 if isinstance(value,CSVINT):
1712 self.__field_dunno1=value
1713 else:
1714 self.__field_dunno1=CSVINT(value,**{ 'default': 0 })
1715
1716 def __delfield_dunno1(self): del self.__field_dunno1
1717
1718 dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None)
1719
1720 def __getfield_dunno2(self):
1721 try: self.__field_dunno2
1722 except:
1723 self.__field_dunno2=CSVINT(**{ 'default': 0 })
1724 return self.__field_dunno2.getvalue()
1725
1726 def __setfield_dunno2(self, value):
1727 if isinstance(value,CSVINT):
1728 self.__field_dunno2=value
1729 else:
1730 self.__field_dunno2=CSVINT(value,**{ 'default': 0 })
1731
1732 def __delfield_dunno2(self): del self.__field_dunno2
1733
1734 dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None)
1735
1736 def __getfield_dunno3(self):
1737 try: self.__field_dunno3
1738 except:
1739 self.__field_dunno3=CSVINT(**{ 'default': 0 })
1740 return self.__field_dunno3.getvalue()
1741
1742 def __setfield_dunno3(self, value):
1743 if isinstance(value,CSVINT):
1744 self.__field_dunno3=value
1745 else:
1746 self.__field_dunno3=CSVINT(value,**{ 'default': 0 })
1747
1748 def __delfield_dunno3(self): del self.__field_dunno3
1749
1750 dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None)
1751
1752 def __getfield_dunno4(self):
1753 try: self.__field_dunno4
1754 except:
1755 self.__field_dunno4=CSVINT(**{ 'default': 0, 'terminator': ord('\r') })
1756 return self.__field_dunno4.getvalue()
1757
1758 def __setfield_dunno4(self, value):
1759 if isinstance(value,CSVINT):
1760 self.__field_dunno4=value
1761 else:
1762 self.__field_dunno4=CSVINT(value,**{ 'default': 0, 'terminator': ord('\r') })
1763
1764 def __delfield_dunno4(self): del self.__field_dunno4
1765
1766 dunno4=property(__getfield_dunno4, __setfield_dunno4, __delfield_dunno4, None)
1767
1768 def iscontainer(self):
1769 return True
1770
1771 def containerelements(self):
1772 yield ('command', self.__field_command, None)
1773 yield ('index', self.__field_index, None)
1774 yield ('file_name', self.__field_file_name, None)
1775 yield ('media_name', self.__field_media_name, None)
1776 yield ('data_len', self.__field_data_len, None)
1777 yield ('media_type', self.__field_media_type, None)
1778 yield ('dunno1', self.__field_dunno1, None)
1779 yield ('dunno2', self.__field_dunno2, None)
1780 yield ('dunno3', self.__field_dunno3, None)
1781 yield ('dunno4', self.__field_dunno4, None)
1782
1783
1784
1785
1786 class list_group_req(BaseProtogenClass):
1787 __fields=['command', 'start_index', 'end_index']
1788
1789 def __init__(self, *args, **kwargs):
1790 dict={}
1791 dict.update(kwargs)
1793 super(list_group_req,self).__init__(**dict)
1795 if self.__class__ is list_group_req:
1796 self._update(args,dict)
1797
1798
1799 def getfields(self):
1800 return self.__fields
1801
1802
1803 def _update(self, args, kwargs):
1804 super(list_group_req,self)._update(args,kwargs)
1805 keys=kwargs.keys()
1806 for key in keys:
1807 if key in self.__fields:
1808 setattr(self, key, kwargs[key])
1809 del kwargs[key]
1810 if __debug__:
1812 self._complainaboutunusedargs(list_group_req,kwargs)
1813 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1814
1816
1817 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1818 'Writes this packet to the supplied buffer'
1819 self._bufferstartoffset=buf.getcurrentoffset()
1820 try: self.__field_command
1821 except:
1822 self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CPGR=' })
1823 self.__field_command.writetobuffer(buf)
1824 try: self.__field_start_index
1825 except:
1826 self.__field_start_index=CSVINT()
1827 self.__field_start_index.writetobuffer(buf)
1828 try: self.__field_end_index
1829 except:
1830 self.__field_end_index=CSVINT(**{ 'terminator': None })
1831 self.__field_end_index.writetobuffer(buf)
1832 self._bufferendoffset=buf.getcurrentoffset()
1833 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1834
1835
1836 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1837 'Reads this packet from the supplied buffer'
1838 self._bufferstartoffset=buf.getcurrentoffset()
1839 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1840 self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CPGR=' })
1841 self.__field_command.readfrombuffer(buf)
1842 self.__field_start_index=CSVINT()
1843 self.__field_start_index.readfrombuffer(buf)
1844 self.__field_end_index=CSVINT(**{ 'terminator': None })
1845 self.__field_end_index.readfrombuffer(buf)
1846 self._bufferendoffset=buf.getcurrentoffset()
1847
1848
1849 def __getfield_command(self):
1850 try: self.__field_command
1851 except:
1852 self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CPGR=' })
1853 return self.__field_command.getvalue()
1854
1855 def __setfield_command(self, value):
1856 if isinstance(value,USTRING):
1857 self.__field_command=value
1858 else:
1859 self.__field_command=USTRING(value,**{ 'terminator': None, 'default': '+CPGR=' })
1860
1861 def __delfield_command(self): del self.__field_command
1862
1863 command=property(__getfield_command, __setfield_command, __delfield_command, None)
1864
1865 def __getfield_start_index(self):
1866 try: self.__field_start_index
1867 except:
1868 self.__field_start_index=CSVINT()
1869 return self.__field_start_index.getvalue()
1870
1871 def __setfield_start_index(self, value):
1872 if isinstance(value,CSVINT):
1873 self.__field_start_index=value
1874 else:
1875 self.__field_start_index=CSVINT(value,)
1876
1877 def __delfield_start_index(self): del self.__field_start_index
1878
1879 start_index=property(__getfield_start_index, __setfield_start_index, __delfield_start_index, None)
1880
1881 def __getfield_end_index(self):
1882 try: self.__field_end_index
1883 except:
1884 self.__field_end_index=CSVINT(**{ 'terminator': None })
1885 return self.__field_end_index.getvalue()
1886
1887 def __setfield_end_index(self, value):
1888 if isinstance(value,CSVINT):
1889 self.__field_end_index=value
1890 else:
1891 self.__field_end_index=CSVINT(value,**{ 'terminator': None })
1892
1893 def __delfield_end_index(self): del self.__field_end_index
1894
1895 end_index=property(__getfield_end_index, __setfield_end_index, __delfield_end_index, None)
1896
1897 def iscontainer(self):
1898 return True
1899
1900 def containerelements(self):
1901 yield ('command', self.__field_command, None)
1902 yield ('start_index', self.__field_start_index, None)
1903 yield ('end_index', self.__field_end_index, None)
1904
1905
1906
1907
1908 class list_group_resp(BaseProtogenClass):
1909 __fields=['command', 'index', 'group_name']
1910
1911 def __init__(self, *args, **kwargs):
1912 dict={}
1913 dict.update(kwargs)
1915 super(list_group_resp,self).__init__(**dict)
1917 if self.__class__ is list_group_resp:
1918 self._update(args,dict)
1919
1920
1921 def getfields(self):
1922 return self.__fields
1923
1924
1925 def _update(self, args, kwargs):
1926 super(list_group_resp,self)._update(args,kwargs)
1927 keys=kwargs.keys()
1928 for key in keys:
1929 if key in self.__fields:
1930 setattr(self, key, kwargs[key])
1931 del kwargs[key]
1932 if __debug__:
1934 self._complainaboutunusedargs(list_group_resp,kwargs)
1935 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1936
1938
1939 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1940 'Writes this packet to the supplied buffer'
1941 self._bufferstartoffset=buf.getcurrentoffset()
1942 self.__field_command.writetobuffer(buf)
1943 self.__field_index.writetobuffer(buf)
1944 self.__field_group_name.writetobuffer(buf)
1945 self._bufferendoffset=buf.getcurrentoffset()
1946 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1947
1948
1949 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1950 'Reads this packet from the supplied buffer'
1951 self._bufferstartoffset=buf.getcurrentoffset()
1952 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1953 self.__field_command=USTRING(**{ 'terminator': ord(' '), 'constant': '+CPGR:' })
1954 self.__field_command.readfrombuffer(buf)
1955 self.__field_index=CSVINT()
1956 self.__field_index.readfrombuffer(buf)
1957 self.__field_group_name=CSVSTRING(**{ 'terminator': None })
1958 self.__field_group_name.readfrombuffer(buf)
1959 self._bufferendoffset=buf.getcurrentoffset()
1960
1961
1962 def __getfield_command(self):
1963 return self.__field_command.getvalue()
1964
1965 def __setfield_command(self, value):
1966 if isinstance(value,USTRING):
1967 self.__field_command=value
1968 else:
1969 self.__field_command=USTRING(value,**{ 'terminator': ord(' '), 'constant': '+CPGR:' })
1970
1971 def __delfield_command(self): del self.__field_command
1972
1973 command=property(__getfield_command, __setfield_command, __delfield_command, None)
1974
1975 def __getfield_index(self):
1976 return self.__field_index.getvalue()
1977
1978 def __setfield_index(self, value):
1979 if isinstance(value,CSVINT):
1980 self.__field_index=value
1981 else:
1982 self.__field_index=CSVINT(value,)
1983
1984 def __delfield_index(self): del self.__field_index
1985
1986 index=property(__getfield_index, __setfield_index, __delfield_index, None)
1987
1988 def __getfield_group_name(self):
1989 return self.__field_group_name.getvalue()
1990
1991 def __setfield_group_name(self, value):
1992 if isinstance(value,CSVSTRING):
1993 self.__field_group_name=value
1994 else:
1995 self.__field_group_name=CSVSTRING(value,**{ 'terminator': None })
1996
1997 def __delfield_group_name(self): del self.__field_group_name
1998
1999 group_name=property(__getfield_group_name, __setfield_group_name, __delfield_group_name, None)
2000
2001 def iscontainer(self):
2002 return True
2003
2004 def containerelements(self):
2005 yield ('command', self.__field_command, None)
2006 yield ('index', self.__field_index, None)
2007 yield ('group_name', self.__field_group_name, None)
2008
2009
2010
2011
2012 class charset_set_req(BaseProtogenClass):
2013 __fields=['command', 'charset']
2014
2015 def __init__(self, *args, **kwargs):
2016 dict={}
2017 dict.update(kwargs)
2019 super(charset_set_req,self).__init__(**dict)
2021 if self.__class__ is charset_set_req:
2022 self._update(args,dict)
2023
2024
2025 def getfields(self):
2026 return self.__fields
2027
2028
2029 def _update(self, args, kwargs):
2030 super(charset_set_req,self)._update(args,kwargs)
2031 keys=kwargs.keys()
2032 for key in keys:
2033 if key in self.__fields:
2034 setattr(self, key, kwargs[key])
2035 del kwargs[key]
2036 if __debug__:
2038 self._complainaboutunusedargs(charset_set_req,kwargs)
2039 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2040
2042
2043 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2044 'Writes this packet to the supplied buffer'
2045 self._bufferstartoffset=buf.getcurrentoffset()
2046 try: self.__field_command
2047 except:
2048 self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CSCS=' })
2049 self.__field_command.writetobuffer(buf)
2050 try: self.__field_charset
2051 except:
2052 self.__field_charset=CSVSTRING(**{ 'terminator': None })
2053 self.__field_charset.writetobuffer(buf)
2054 self._bufferendoffset=buf.getcurrentoffset()
2055 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2056
2057
2058 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2059 'Reads this packet from the supplied buffer'
2060 self._bufferstartoffset=buf.getcurrentoffset()
2061 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2062 self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CSCS=' })
2063 self.__field_command.readfrombuffer(buf)
2064 self.__field_charset=CSVSTRING(**{ 'terminator': None })
2065 self.__field_charset.readfrombuffer(buf)
2066 self._bufferendoffset=buf.getcurrentoffset()
2067
2068
2069 def __getfield_command(self):
2070 try: self.__field_command
2071 except:
2072 self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CSCS=' })
2073 return self.__field_command.getvalue()
2074
2075 def __setfield_command(self, value):
2076 if isinstance(value,USTRING):
2077 self.__field_command=value
2078 else:
2079 self.__field_command=USTRING(value,**{ 'terminator': None, 'default': '+CSCS=' })
2080
2081 def __delfield_command(self): del self.__field_command
2082
2083 command=property(__getfield_command, __setfield_command, __delfield_command, None)
2084
2085 def __getfield_charset(self):
2086 try: self.__field_charset
2087 except:
2088 self.__field_charset=CSVSTRING(**{ 'terminator': None })
2089 return self.__field_charset.getvalue()
2090
2091 def __setfield_charset(self, value):
2092 if isinstance(value,CSVSTRING):
2093 self.__field_charset=value
2094 else:
2095 self.__field_charset=CSVSTRING(value,**{ 'terminator': None })
2096
2097 def __delfield_charset(self): del self.__field_charset
2098
2099 charset=property(__getfield_charset, __setfield_charset, __delfield_charset, None)
2100
2101 def iscontainer(self):
2102 return True
2103
2104 def containerelements(self):
2105 yield ('command', self.__field_command, None)
2106 yield ('charset', self.__field_charset, None)
2107
2108
2109
2110
2111 class select_storage_req(BaseProtogenClass):
2112 __fields=['command', 'storage']
2113
2114 def __init__(self, *args, **kwargs):
2115 dict={}
2116 dict.update(kwargs)
2118 super(select_storage_req,self).__init__(**dict)
2120 if self.__class__ is select_storage_req:
2121 self._update(args,dict)
2122
2123
2124 def getfields(self):
2125 return self.__fields
2126
2127
2128 def _update(self, args, kwargs):
2129 super(select_storage_req,self)._update(args,kwargs)
2130 keys=kwargs.keys()
2131 for key in keys:
2132 if key in self.__fields:
2133 setattr(self, key, kwargs[key])
2134 del kwargs[key]
2135 if __debug__:
2137 self._complainaboutunusedargs(select_storage_req,kwargs)
2138 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2139
2141
2142 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2143 'Writes this packet to the supplied buffer'
2144 self._bufferstartoffset=buf.getcurrentoffset()
2145 try: self.__field_command
2146 except:
2147 self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CPBS=' })
2148 self.__field_command.writetobuffer(buf)
2149 try: self.__field_storage
2150 except:
2151 self.__field_storage=CSVSTRING(**{ 'terminator': None })
2152 self.__field_storage.writetobuffer(buf)
2153 self._bufferendoffset=buf.getcurrentoffset()
2154 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2155
2156
2157 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2158 'Reads this packet from the supplied buffer'
2159 self._bufferstartoffset=buf.getcurrentoffset()
2160 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2161 self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CPBS=' })
2162 self.__field_command.readfrombuffer(buf)
2163 self.__field_storage=CSVSTRING(**{ 'terminator': None })
2164 self.__field_storage.readfrombuffer(buf)
2165 self._bufferendoffset=buf.getcurrentoffset()
2166
2167
2168 def __getfield_command(self):
2169 try: self.__field_command
2170 except:
2171 self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CPBS=' })
2172 return self.__field_command.getvalue()
2173
2174 def __setfield_command(self, value):
2175 if isinstance(value,USTRING):
2176 self.__field_command=value
2177 else:
2178 self.__field_command=USTRING(value,**{ 'terminator': None, 'default': '+CPBS=' })
2179
2180 def __delfield_command(self): del self.__field_command
2181
2182 command=property(__getfield_command, __setfield_command, __delfield_command, None)
2183
2184 def __getfield_storage(self):
2185 try: self.__field_storage
2186 except:
2187 self.__field_storage=CSVSTRING(**{ 'terminator': None })
2188 return self.__field_storage.getvalue()
2189
2190 def __setfield_storage(self, value):
2191 if isinstance(value,CSVSTRING):
2192 self.__field_storage=value
2193 else:
2194 self.__field_storage=CSVSTRING(value,**{ 'terminator': None })
2195
2196 def __delfield_storage(self): del self.__field_storage
2197
2198 storage=property(__getfield_storage, __setfield_storage, __delfield_storage, None)
2199
2200 def iscontainer(self):
2201 return True
2202
2203 def containerelements(self):
2204 yield ('command', self.__field_command, None)
2205 yield ('storage', self.__field_storage, None)
2206
2207
2208
2209
2210 class select_storage_resp(BaseProtogenClass):
2211 __fields=['command', 'storage', 'used_slots_count', 'total_slots_count', 'dunno']
2212
2213 def __init__(self, *args, **kwargs):
2214 dict={}
2215 dict.update(kwargs)
2217 super(select_storage_resp,self).__init__(**dict)
2219 if self.__class__ is select_storage_resp:
2220 self._update(args,dict)
2221
2222
2223 def getfields(self):
2224 return self.__fields
2225
2226
2227 def _update(self, args, kwargs):
2228 super(select_storage_resp,self)._update(args,kwargs)
2229 keys=kwargs.keys()
2230 for key in keys:
2231 if key in self.__fields:
2232 setattr(self, key, kwargs[key])
2233 del kwargs[key]
2234 if __debug__:
2236 self._complainaboutunusedargs(select_storage_resp,kwargs)
2237 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2238
2240
2241 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2242 'Writes this packet to the supplied buffer'
2243 self._bufferstartoffset=buf.getcurrentoffset()
2244 self.__field_command.writetobuffer(buf)
2245 self.__field_storage.writetobuffer(buf)
2246 self.__field_used_slots_count.writetobuffer(buf)
2247 self.__field_total_slots_count.writetobuffer(buf)
2248 self.__field_dunno.writetobuffer(buf)
2249 self._bufferendoffset=buf.getcurrentoffset()
2250 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2251
2252
2253 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2254 'Reads this packet from the supplied buffer'
2255 self._bufferstartoffset=buf.getcurrentoffset()
2256 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2257 self.__field_command=USTRING(**{ 'terminator': ord(' '), 'constant': '+CPBS:' })
2258 self.__field_command.readfrombuffer(buf)
2259 self.__field_storage=CSVSTRING()
2260 self.__field_storage.readfrombuffer(buf)
2261 self.__field_used_slots_count=CSVINT()
2262 self.__field_used_slots_count.readfrombuffer(buf)
2263 self.__field_total_slots_count=CSVINT()
2264 self.__field_total_slots_count.readfrombuffer(buf)
2265 self.__field_dunno=CSVINT(**{ 'terminator': None })
2266 self.__field_dunno.readfrombuffer(buf)
2267 self._bufferendoffset=buf.getcurrentoffset()
2268
2269
2270 def __getfield_command(self):
2271 return self.__field_command.getvalue()
2272
2273 def __setfield_command(self, value):
2274 if isinstance(value,USTRING):
2275 self.__field_command=value
2276 else:
2277 self.__field_command=USTRING(value,**{ 'terminator': ord(' '), 'constant': '+CPBS:' })
2278
2279 def __delfield_command(self): del self.__field_command
2280
2281 command=property(__getfield_command, __setfield_command, __delfield_command, None)
2282
2283 def __getfield_storage(self):
2284 return self.__field_storage.getvalue()
2285
2286 def __setfield_storage(self, value):
2287 if isinstance(value,CSVSTRING):
2288 self.__field_storage=value
2289 else:
2290 self.__field_storage=CSVSTRING(value,)
2291
2292 def __delfield_storage(self): del self.__field_storage
2293
2294 storage=property(__getfield_storage, __setfield_storage, __delfield_storage, None)
2295
2296 def __getfield_used_slots_count(self):
2297 return self.__field_used_slots_count.getvalue()
2298
2299 def __setfield_used_slots_count(self, value):
2300 if isinstance(value,CSVINT):
2301 self.__field_used_slots_count=value
2302 else:
2303 self.__field_used_slots_count=CSVINT(value,)
2304
2305 def __delfield_used_slots_count(self): del self.__field_used_slots_count
2306
2307 used_slots_count=property(__getfield_used_slots_count, __setfield_used_slots_count, __delfield_used_slots_count, None)
2308
2309 def __getfield_total_slots_count(self):
2310 return self.__field_total_slots_count.getvalue()
2311
2312 def __setfield_total_slots_count(self, value):
2313 if isinstance(value,CSVINT):
2314 self.__field_total_slots_count=value
2315 else:
2316 self.__field_total_slots_count=CSVINT(value,)
2317
2318 def __delfield_total_slots_count(self): del self.__field_total_slots_count
2319
2320 total_slots_count=property(__getfield_total_slots_count, __setfield_total_slots_count, __delfield_total_slots_count, None)
2321
2322 def __getfield_dunno(self):
2323 return self.__field_dunno.getvalue()
2324
2325 def __setfield_dunno(self, value):
2326 if isinstance(value,CSVINT):
2327 self.__field_dunno=value
2328 else:
2329 self.__field_dunno=CSVINT(value,**{ 'terminator': None })
2330
2331 def __delfield_dunno(self): del self.__field_dunno
2332
2333 dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, None)
2334
2335 def iscontainer(self):
2336 return True
2337
2338 def containerelements(self):
2339 yield ('command', self.__field_command, None)
2340 yield ('storage', self.__field_storage, None)
2341 yield ('used_slots_count', self.__field_used_slots_count, None)
2342 yield ('total_slots_count', self.__field_total_slots_count, None)
2343 yield ('dunno', self.__field_dunno, None)
2344
2345
2346
2347
2348 class read_phonebook_req(BaseProtogenClass):
2349 __fields=['command', 'start_index', 'end_index']
2350
2351 def __init__(self, *args, **kwargs):
2352 dict={}
2353 dict.update(kwargs)
2355 super(read_phonebook_req,self).__init__(**dict)
2357 if self.__class__ is read_phonebook_req:
2358 self._update(args,dict)
2359
2360
2361 def getfields(self):
2362 return self.__fields
2363
2364
2365 def _update(self, args, kwargs):
2366 super(read_phonebook_req,self)._update(args,kwargs)
2367 keys=kwargs.keys()
2368 for key in keys:
2369 if key in self.__fields:
2370 setattr(self, key, kwargs[key])
2371 del kwargs[key]
2372 if __debug__:
2374 self._complainaboutunusedargs(read_phonebook_req,kwargs)
2375 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2376
2378
2379 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2380 'Writes this packet to the supplied buffer'
2381 self._bufferstartoffset=buf.getcurrentoffset()
2382 try: self.__field_command
2383 except:
2384 self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CPBR=' })
2385 self.__field_command.writetobuffer(buf)
2386 try: self.__field_start_index
2387 except:
2388 self.__field_start_index=CSVINT()
2389 self.__field_start_index.writetobuffer(buf)
2390 try: self.__field_end_index
2391 except:
2392 self.__field_end_index=CSVINT(**{ 'terminator': None })
2393 self.__field_end_index.writetobuffer(buf)
2394 self._bufferendoffset=buf.getcurrentoffset()
2395 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2396
2397
2398 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2399 'Reads this packet from the supplied buffer'
2400 self._bufferstartoffset=buf.getcurrentoffset()
2401 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2402 self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CPBR=' })
2403 self.__field_command.readfrombuffer(buf)
2404 self.__field_start_index=CSVINT()
2405 self.__field_start_index.readfrombuffer(buf)
2406 self.__field_end_index=CSVINT(**{ 'terminator': None })
2407 self.__field_end_index.readfrombuffer(buf)
2408 self._bufferendoffset=buf.getcurrentoffset()
2409
2410
2411 def __getfield_command(self):
2412 try: self.__field_command
2413 except:
2414 self.__field_command=USTRING(**{ 'terminator': None, 'default': '+CPBR=' })
2415 return self.__field_command.getvalue()
2416
2417 def __setfield_command(self, value):
2418 if isinstance(value,USTRING):
2419 self.__field_command=value
2420 else:
2421 self.__field_command=USTRING(value,**{ 'terminator': None, 'default': '+CPBR=' })
2422
2423 def __delfield_command(self): del self.__field_command
2424
2425 command=property(__getfield_command, __setfield_command, __delfield_command, None)
2426
2427 def __getfield_start_index(self):
2428 try: self.__field_start_index
2429 except:
2430 self.__field_start_index=CSVINT()
2431 return self.__field_start_index.getvalue()
2432
2433 def __setfield_start_index(self, value):
2434 if isinstance(value,CSVINT):
2435 self.__field_start_index=value
2436 else:
2437 self.__field_start_index=CSVINT(value,)
2438
2439 def __delfield_start_index(self): del self.__field_start_index
2440
2441 start_index=property(__getfield_start_index, __setfield_start_index, __delfield_start_index, None)
2442
2443 def __getfield_end_index(self):
2444 try: self.__field_end_index
2445 except:
2446 self.__field_end_index=CSVINT(**{ 'terminator': None })
2447 return self.__field_end_index.getvalue()
2448
2449 def __setfield_end_index(self, value):
2450 if isinstance(value,CSVINT):
2451 self.__field_end_index=value
2452 else:
2453 self.__field_end_index=CSVINT(value,**{ 'terminator': None })
2454
2455 def __delfield_end_index(self): del self.__field_end_index
2456
2457 end_index=property(__getfield_end_index, __setfield_end_index, __delfield_end_index, None)
2458
2459 def iscontainer(self):
2460 return True
2461
2462 def containerelements(self):
2463 yield ('command', self.__field_command, None)
2464 yield ('start_index', self.__field_start_index, None)
2465 yield ('end_index', self.__field_end_index, None)
2466
2467
2468
2469
2470 class read_phonebook_resp(BaseProtogenClass):
2471 __fields=['sim', 'command', 'index', 'group', 'mobile', 'mobile_type', 'home', 'home_type', 'office', 'office_type', 'name', 'email', 'memo']
2472
2473 def __init__(self, *args, **kwargs):
2474 dict={}
2475 dict.update(kwargs)
2477 super(read_phonebook_resp,self).__init__(**dict)
2479 if self.__class__ is read_phonebook_resp:
2480 self._update(args,dict)
2481
2482
2483 def getfields(self):
2484 return self.__fields
2485
2486
2487 def _update(self, args, kwargs):
2488 super(read_phonebook_resp,self)._update(args,kwargs)
2489 keys=kwargs.keys()
2490 for key in keys:
2491 if key in self.__fields:
2492 setattr(self, key, kwargs[key])
2493 del kwargs[key]
2494 if __debug__:
2496 self._complainaboutunusedargs(read_phonebook_resp,kwargs)
2497 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2498 try: self.__field_sim
2500 except:
2501 self.__field_sim=BOOL(**{ 'default': False })
2502
2503
2504 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2505 'Writes this packet to the supplied buffer'
2506 self._bufferstartoffset=buf.getcurrentoffset()
2507 self.__field_command.writetobuffer(buf)
2508 self.__field_index.writetobuffer(buf)
2509 self.__field_group.writetobuffer(buf)
2510 self.__field_mobile.writetobuffer(buf)
2511 self.__field_mobile_type.writetobuffer(buf)
2512 self.__field_home.writetobuffer(buf)
2513 self.__field_home_type.writetobuffer(buf)
2514 self.__field_office.writetobuffer(buf)
2515 self.__field_office_type.writetobuffer(buf)
2516 self.__field_name.writetobuffer(buf)
2517 self.__field_email.writetobuffer(buf)
2518 self.__field_memo.writetobuffer(buf)
2519 self._bufferendoffset=buf.getcurrentoffset()
2520 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2521
2522
2523 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2524 'Reads this packet from the supplied buffer'
2525 self._bufferstartoffset=buf.getcurrentoffset()
2526 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2527 self.__field_command=USTRING(**{ 'terminator': ord(' '), 'constant': '+CPBR:' })
2528 self.__field_command.readfrombuffer(buf)
2529 self.__field_index=CSVINT()
2530 self.__field_index.readfrombuffer(buf)
2531 self.__field_group=CSVINT()
2532 self.__field_group.readfrombuffer(buf)
2533 self.__field_mobile=CSVSTRING()
2534 self.__field_mobile.readfrombuffer(buf)
2535 self.__field_mobile_type=CSVINT()
2536 self.__field_mobile_type.readfrombuffer(buf)
2537 self.__field_home=CSVSTRING()
2538 self.__field_home.readfrombuffer(buf)
2539 self.__field_home_type=CSVINT()
2540 self.__field_home_type.readfrombuffer(buf)
2541 self.__field_office=CSVSTRING()
2542 self.__field_office.readfrombuffer(buf)
2543 self.__field_office_type=CSVINT()
2544 self.__field_office_type.readfrombuffer(buf)
2545 self.__field_name=CSVSTRING()
2546 self.__field_name.readfrombuffer(buf)
2547 self.__field_email=CSVSTRING()
2548 self.__field_email.readfrombuffer(buf)
2549 self.__field_memo=CSVSTRING()
2550 self.__field_memo.readfrombuffer(buf)
2551 self._bufferendoffset=buf.getcurrentoffset()
2552
2553
2554 def __getfield_sim(self):
2555 try: self.__field_sim
2556 except:
2557 self.__field_sim=BOOL(**{ 'default': False })
2558 return self.__field_sim.getvalue()
2559
2560 def __setfield_sim(self, value):
2561 if isinstance(value,BOOL):
2562 self.__field_sim=value
2563 else:
2564 self.__field_sim=BOOL(value,**{ 'default': False })
2565
2566 def __delfield_sim(self): del self.__field_sim
2567
2568 sim=property(__getfield_sim, __setfield_sim, __delfield_sim, None)
2569
2570 def __getfield_command(self):
2571 return self.__field_command.getvalue()
2572
2573 def __setfield_command(self, value):
2574 if isinstance(value,USTRING):
2575 self.__field_command=value
2576 else:
2577 self.__field_command=USTRING(value,**{ 'terminator': ord(' '), 'constant': '+CPBR:' })
2578
2579 def __delfield_command(self): del self.__field_command
2580
2581 command=property(__getfield_command, __setfield_command, __delfield_command, None)
2582
2583 def __getfield_index(self):
2584 return self.__field_index.getvalue()
2585
2586 def __setfield_index(self, value):
2587 if isinstance(value,CSVINT):
2588 self.__field_index=value
2589 else:
2590 self.__field_index=CSVINT(value,)
2591
2592 def __delfield_index(self): del self.__field_index
2593
2594 index=property(__getfield_index, __setfield_index, __delfield_index, None)
2595
2596 def __getfield_group(self):
2597 return self.__field_group.getvalue()
2598
2599 def __setfield_group(self, value):
2600 if isinstance(value,CSVINT):
2601 self.__field_group=value
2602 else:
2603 self.__field_group=CSVINT(value,)
2604
2605 def __delfield_group(self): del self.__field_group
2606
2607 group=property(__getfield_group, __setfield_group, __delfield_group, None)
2608
2609 def __getfield_mobile(self):
2610 return self.__field_mobile.getvalue()
2611
2612 def __setfield_mobile(self, value):
2613 if isinstance(value,CSVSTRING):
2614 self.__field_mobile=value
2615 else:
2616 self.__field_mobile=CSVSTRING(value,)
2617
2618 def __delfield_mobile(self): del self.__field_mobile
2619
2620 mobile=property(__getfield_mobile, __setfield_mobile, __delfield_mobile, None)
2621
2622 def __getfield_mobile_type(self):
2623 return self.__field_mobile_type.getvalue()
2624
2625 def __setfield_mobile_type(self, value):
2626 if isinstance(value,CSVINT):
2627 self.__field_mobile_type=value
2628 else:
2629 self.__field_mobile_type=CSVINT(value,)
2630
2631 def __delfield_mobile_type(self): del self.__field_mobile_type
2632
2633 mobile_type=property(__getfield_mobile_type, __setfield_mobile_type, __delfield_mobile_type, None)
2634
2635 def __getfield_home(self):
2636 return self.__field_home.getvalue()
2637
2638 def __setfield_home(self, value):
2639 if isinstance(value,CSVSTRING):
2640 self.__field_home=value
2641 else:
2642 self.__field_home=CSVSTRING(value,)
2643
2644 def __delfield_home(self): del self.__field_home
2645
2646 home=property(__getfield_home, __setfield_home, __delfield_home, None)
2647
2648 def __getfield_home_type(self):
2649 return self.__field_home_type.getvalue()
2650
2651 def __setfield_home_type(self, value):
2652 if isinstance(value,CSVINT):
2653 self.__field_home_type=value
2654 else:
2655 self.__field_home_type=CSVINT(value,)
2656
2657 def __delfield_home_type(self): del self.__field_home_type
2658
2659 home_type=property(__getfield_home_type, __setfield_home_type, __delfield_home_type, None)
2660
2661 def __getfield_office(self):
2662 return self.__field_office.getvalue()
2663
2664 def __setfield_office(self, value):
2665 if isinstance(value,CSVSTRING):
2666 self.__field_office=value
2667 else:
2668 self.__field_office=CSVSTRING(value,)
2669
2670 def __delfield_office(self): del self.__field_office
2671
2672 office=property(__getfield_office, __setfield_office, __delfield_office, None)
2673
2674 def __getfield_office_type(self):
2675 return self.__field_office_type.getvalue()
2676
2677 def __setfield_office_type(self, value):
2678 if isinstance(value,CSVINT):
2679 self.__field_office_type=value
2680 else:
2681 self.__field_office_type=CSVINT(value,)
2682
2683 def __delfield_office_type(self): del self.__field_office_type
2684
2685 office_type=property(__getfield_office_type, __setfield_office_type, __delfield_office_type, None)
2686
2687 def __getfield_name(self):
2688 return self.__field_name.getvalue()
2689
2690 def __setfield_name(self, value):
2691 if isinstance(value,CSVSTRING):
2692 self.__field_name=value
2693 else:
2694 self.__field_name=CSVSTRING(value,)
2695
2696 def __delfield_name(self): del self.__field_name
2697
2698 name=property(__getfield_name, __setfield_name, __delfield_name, None)
2699
2700 def __getfield_email(self):
2701 return self.__field_email.getvalue()
2702
2703 def __setfield_email(self, value):
2704 if isinstance(value,CSVSTRING):
2705 self.__field_email=value
2706 else:
2707 self.__field_email=CSVSTRING(value,)
2708
2709 def __delfield_email(self): del self.__field_email
2710
2711 email=property(__getfield_email, __setfield_email, __delfield_email, None)
2712
2713 def __getfield_memo(self):
2714 return self.__field_memo.getvalue()
2715
2716 def __setfield_memo(self, value):
2717 if isinstance(value,CSVSTRING):
2718 self.__field_memo=value
2719 else:
2720 self.__field_memo=CSVSTRING(value,)
2721
2722 def __delfield_memo(self): del self.__field_memo
2723
2724 memo=property(__getfield_memo, __setfield_memo, __delfield_memo, None)
2725
2726 def iscontainer(self):
2727 return True
2728
2729 def containerelements(self):
2730 yield ('sim', self.__field_sim, None)
2731 yield ('command', self.__field_command, None)
2732 yield ('index', self.__field_index, None)
2733 yield ('group', self.__field_group, None)
2734 yield ('mobile', self.__field_mobile, None)
2735 yield ('mobile_type', self.__field_mobile_type, None)
2736 yield ('home', self.__field_home, None)
2737 yield ('home_type', self.__field_home_type, None)
2738 yield ('office', self.__field_office, None)
2739 yield ('office_type', self.__field_office_type, None)
2740 yield ('name', self.__field_name, None)
2741 yield ('email', self.__field_email, None)
2742 yield ('memo', self.__field_memo, None)
2743
2744
2745
2746
2747 class read_sim_phonebook_resp(BaseProtogenClass):
2748 __fields=['command', 'index', 'group', 'mobile', 'mobile_type', 'name', 'home', 'office', 'email', 'memo', 'sim']
2749
2750 def __init__(self, *args, **kwargs):
2751 dict={}
2752 dict.update(kwargs)
2754 super(read_sim_phonebook_resp,self).__init__(**dict)
2756 if self.__class__ is read_sim_phonebook_resp:
2757 self._update(args,dict)
2758
2759
2760 def getfields(self):
2761 return self.__fields
2762
2763
2764 def _update(self, args, kwargs):
2765 super(read_sim_phonebook_resp,self)._update(args,kwargs)
2766 keys=kwargs.keys()
2767 for key in keys:
2768 if key in self.__fields:
2769 setattr(self, key, kwargs[key])
2770 del kwargs[key]
2771 if __debug__:
2773 self._complainaboutunusedargs(read_sim_phonebook_resp,kwargs)
2774 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2775 try: self.__field_home
2777 except:
2778 self.__field_home=USTRING(**{ 'terminator': None, 'default': '' })
2779 try: self.__field_office
2780 except:
2781 self.__field_office=USTRING(**{ 'terminator': None, 'default': '' })
2782 try: self.__field_email
2783 except:
2784 self.__field_email=USTRING(**{ 'terminator': None, 'default': '' })
2785 try: self.__field_memo
2786 except:
2787 self.__field_memo=USTRING(**{ 'terminator': None, 'default': '' })
2788 try: self.__field_sim
2789 except:
2790 self.__field_sim=BOOL(**{ 'default': True })
2791
2792
2793 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2794 'Writes this packet to the supplied buffer'
2795 self._bufferstartoffset=buf.getcurrentoffset()
2796 self.__field_command.writetobuffer(buf)
2797 self.__field_index.writetobuffer(buf)
2798 self.__field_group.writetobuffer(buf)
2799 self.__field_mobile.writetobuffer(buf)
2800 self.__field_mobile_type.writetobuffer(buf)
2801 self.__field_name.writetobuffer(buf)
2802 self._bufferendoffset=buf.getcurrentoffset()
2803 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2804
2805
2806 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2807 'Reads this packet from the supplied buffer'
2808 self._bufferstartoffset=buf.getcurrentoffset()
2809 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2810 self.__field_command=USTRING(**{ 'terminator': ord(' '), 'constant': '+CPBR:' })
2811 self.__field_command.readfrombuffer(buf)
2812 self.__field_index=CSVINT()
2813 self.__field_index.readfrombuffer(buf)
2814 self.__field_group=CSVINT()
2815 self.__field_group.readfrombuffer(buf)
2816 self.__field_mobile=CSVSTRING()
2817 self.__field_mobile.readfrombuffer(buf)
2818 self.__field_mobile_type=CSVINT()
2819 self.__field_mobile_type.readfrombuffer(buf)
2820 self.__field_name=CSVSTRING()
2821 self.__field_name.readfrombuffer(buf)
2822 self._bufferendoffset=buf.getcurrentoffset()
2823
2824
2825 def __getfield_command(self):
2826 return self.__field_command.getvalue()
2827
2828 def __setfield_command(self, value):
2829 if isinstance(value,USTRING):
2830 self.__field_command=value
2831 else:
2832 self.__field_command=USTRING(value,**{ 'terminator': ord(' '), 'constant': '+CPBR:' })
2833
2834 def __delfield_command(self): del self.__field_command
2835
2836 command=property(__getfield_command, __setfield_command, __delfield_command, None)
2837
2838 def __getfield_index(self):
2839 return self.__field_index.getvalue()
2840
2841 def __setfield_index(self, value):
2842 if isinstance(value,CSVINT):
2843 self.__field_index=value
2844 else:
2845 self.__field_index=CSVINT(value,)
2846
2847 def __delfield_index(self): del self.__field_index
2848
2849 index=property(__getfield_index, __setfield_index, __delfield_index, None)
2850
2851 def __getfield_group(self):
2852 return self.__field_group.getvalue()
2853
2854 def __setfield_group(self, value):
2855 if isinstance(value,CSVINT):
2856 self.__field_group=value
2857 else:
2858 self.__field_group=CSVINT(value,)
2859
2860 def __delfield_group(self): del self.__field_group
2861
2862 group=property(__getfield_group, __setfield_group, __delfield_group, None)
2863
2864 def __getfield_mobile(self):
2865 return self.__field_mobile.getvalue()
2866
2867 def __setfield_mobile(self, value):
2868 if isinstance(value,CSVSTRING):
2869 self.__field_mobile=value
2870 else:
2871 self.__field_mobile=CSVSTRING(value,)
2872
2873 def __delfield_mobile(self): del self.__field_mobile
2874
2875 mobile=property(__getfield_mobile, __setfield_mobile, __delfield_mobile, None)
2876
2877 def __getfield_mobile_type(self):
2878 return self.__field_mobile_type.getvalue()
2879
2880 def __setfield_mobile_type(self, value):
2881 if isinstance(value,CSVINT):
2882 self.__field_mobile_type=value
2883 else:
2884 self.__field_mobile_type=CSVINT(value,)
2885
2886 def __delfield_mobile_type(self): del self.__field_mobile_type
2887
2888 mobile_type=property(__getfield_mobile_type, __setfield_mobile_type, __delfield_mobile_type, None)
2889
2890 def __getfield_name(self):
2891 return self.__field_name.getvalue()
2892
2893 def __setfield_name(self, value):
2894 if isinstance(value,CSVSTRING):
2895 self.__field_name=value
2896 else:
2897 self.__field_name=CSVSTRING(value,)
2898
2899 def __delfield_name(self): del self.__field_name
2900
2901 name=property(__getfield_name, __setfield_name, __delfield_name, None)
2902
2903 def __getfield_home(self):
2904 try: self.__field_home
2905 except:
2906 self.__field_home=USTRING(**{ 'terminator': None, 'default': '' })
2907 return self.__field_home.getvalue()
2908
2909 def __setfield_home(self, value):
2910 if isinstance(value,USTRING):
2911 self.__field_home=value
2912 else:
2913 self.__field_home=USTRING(value,**{ 'terminator': None, 'default': '' })
2914
2915 def __delfield_home(self): del self.__field_home
2916
2917 home=property(__getfield_home, __setfield_home, __delfield_home, None)
2918
2919 def __getfield_office(self):
2920 try: self.__field_office
2921 except:
2922 self.__field_office=USTRING(**{ 'terminator': None, 'default': '' })
2923 return self.__field_office.getvalue()
2924
2925 def __setfield_office(self, value):
2926 if isinstance(value,USTRING):
2927 self.__field_office=value
2928 else:
2929 self.__field_office=USTRING(value,**{ 'terminator': None, 'default': '' })
2930
2931 def __delfield_office(self): del self.__field_office
2932
2933 office=property(__getfield_office, __setfield_office, __delfield_office, None)
2934
2935 def __getfield_email(self):
2936 try: self.__field_email
2937 except:
2938 self.__field_email=USTRING(**{ 'terminator': None, 'default': '' })
2939 return self.__field_email.getvalue()
2940
2941 def __setfield_email(self, value):
2942 if isinstance(value,USTRING):
2943 self.__field_email=value
2944 else:
2945 self.__field_email=USTRING(value,**{ 'terminator': None, 'default': '' })
2946
2947 def __delfield_email(self): del self.__field_email
2948
2949 email=property(__getfield_email, __setfield_email, __delfield_email, None)
2950
2951 def __getfield_memo(self):
2952 try: self.__field_memo
2953 except:
2954 self.__field_memo=USTRING(**{ 'terminator': None, 'default': '' })
2955 return self.__field_memo.getvalue()
2956
2957 def __setfield_memo(self, value):
2958 if isinstance(value,USTRING):
2959 self.__field_memo=value
2960 else:
2961 self.__field_memo=USTRING(value,**{ 'terminator': None, 'default': '' })
2962
2963 def __delfield_memo(self): del self.__field_memo
2964
2965 memo=property(__getfield_memo, __setfield_memo, __delfield_memo, None)
2966
2967 def __getfield_sim(self):
2968 try: self.__field_sim
2969 except:
2970 self.__field_sim=BOOL(**{ 'default': True })
2971 return self.__field_sim.getvalue()
2972
2973 def __setfield_sim(self, value):
2974 if isinstance(value,BOOL):