0001
0003 """Various descriptions of data specific to Motorola phones"""
0004
0005 from prototypes import *
0006 from prototypes_moto import *
0007 from p_etsi import *
0008
0009 UINT=UINTlsb
0011 BOOL=BOOLlsb
0012
0013 CHARSET_8859_1="8859-1"
0015 CHARSET_8859_A="8859-A"
0016 CHARSET_8859_C="8859-C"
0017 CHARSET_8859_H="8859-H"
0018 CHARSET_ASCII="ASCII"
0019 CHARSET_GSM="GSM"
0020 CHARSET_KSC5601="KSC5601"
0021 CHARSET_UCS2="UCS2"
0022 CHARSET_UTF8="UTF8"
0023
0024 MODE_MODEM=0
0026 MODE_PHONEBOOK=2
0027 MODE_OBEX=22
0028
0029 PB_DIALED='DC'
0031 PB_MISSED='MC'
0032 PB_MAIN='AD'
0033 PB_INCOMING='RC'
0034 PB_QUICKDIAL='QD'
0035
0036 LOCAL_TYPE_LOCAL=129
0037 LOCAL_TYPE_INTERNATIONAL=145
0038 LOCAL_TYPE_UNKNOWN=128
0039
0040 NUMBER_TYPE_WORK=0
0041 NUMBER_TYPE_HOME=1
0042 NUMBER_TYPE_MAIN=2
0043 NUMBER_TYPE_MOBILE=3
0044 NUMBER_TYPE_FAX=4
0045 NUMBER_TYPE_PAGER=5
0046 NUMBER_TYPE_EMAIL=6
0047 NUMBER_TYPE_MAILING_LIST=7
0048 NUMBER_TYPE_MOBILE2=8
0049 NUMBER_TYPE_EMAIL2=9
0050 NUMBER_TYPE=frozenset([NUMBER_TYPE_WORK, NUMBER_TYPE_HOME, NUMBER_TYPE_MAIN,
0051 NUMBER_TYPE_MOBILE, NUMBER_TYPE_FAX, NUMBER_TYPE_PAGER,
0052 NUMBER_TYPE_MOBILE2])
0053 EMAIL_TYPE=frozenset([NUMBER_TYPE_EMAIL, NUMBER_TYPE_EMAIL2])
0054 NUMBER_TYPE_NAME={
0055 NUMBER_TYPE_WORK: 'office',
0056 NUMBER_TYPE_HOME: 'home',
0057 NUMBER_TYPE_MAIN: 'main',
0058 NUMBER_TYPE_MOBILE: 'cell',
0059 NUMBER_TYPE_FAX: 'fax',
0060 NUMBER_TYPE_PAGER: 'pager',
0061 NUMBER_TYPE_MOBILE2: 'cell',
0062 }
0063 NUMBER_TYPE_CODE={
0064 'office': NUMBER_TYPE_WORK,
0065 'home': NUMBER_TYPE_HOME,
0066 'main': NUMBER_TYPE_MAIN,
0067 'cell': NUMBER_TYPE_MOBILE,
0068 'fax': NUMBER_TYPE_FAX,
0069 'pager': NUMBER_TYPE_PAGER }
0070
0071 PB_MAX_NUMBER_LEN=32
0072 PB_MAX_NAME_LEN=24
0073 PB_MAX_EMAIL_LEN=48
0074
0075 PB_TOTAL_ENTRIES=500
0076 PB_RANGE=xrange(1,PB_TOTAL_ENTRIES+1)
0077 PB_TOTAL_MISSED_CALLS=60
0078 PB_TOTAL_DIALED_CALLS=60
0079 PB_TOTAL_RECEIVED_CALLS=60
0080
0081 PB_TOTAL_GROUP=30
0082 PB_GROUP_RANGE=xrange(1, PB_TOTAL_GROUP+1)
0083 PB_GROUP_NAME_LEN=24
0084
0085 RT_BUILTIN=0x0C
0086 RT_CUSTOM=0x0D
0087 RT_INDEX_FILE='/MyToneDB.db'
0088
0089 SMS_INBOX="IM"
0091 SMS_OUTBOX="OM"
0092 SMS_INFO="BM"
0093 SMS_DRAFTS="DM"
0094 SMS_COMBINE="MT"
0095
0096 SMS_REC_UNREAD="REC UNREAD"
0097 SMS_REC_READ="REC READ"
0098 SMS_STO_UNSENT="STO UNSENT"
0099 SMS_STO_SENT="STO SENT"
0100 SMS_ALL="ALL"
0101 SMS_HEADER_ONLY="HEADER ONLY"
0102
0103 SMS_INDEX_RANGE=xrange(1, 353)
0104
0105 class esnrequest(BaseProtogenClass):
0106 __fields=['command']
0107
0108 def __init__(self, *args, **kwargs):
0109 dict={}
0110 dict.update(kwargs)
0112 super(esnrequest,self).__init__(**dict)
0114 if self.__class__ is esnrequest:
0115 self._update(args,dict)
0116
0117
0118 def getfields(self):
0119 return self.__fields
0120
0121
0122 def _update(self, args, kwargs):
0123 super(esnrequest,self)._update(args,kwargs)
0124 keys=kwargs.keys()
0125 for key in keys:
0126 if key in self.__fields:
0127 setattr(self, key, kwargs[key])
0128 del kwargs[key]
0129 if __debug__:
0131 self._complainaboutunusedargs(esnrequest,kwargs)
0132 if len(args):
0133 dict2={ 'quotechar': None, 'terminator': None, 'default': '+CGSN' }
0134 dict2.update(kwargs)
0135 kwargs=dict2
0136 self.__field_command=CSVSTRING(*args,**dict2)
0137
0139
0140 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0141 'Writes this packet to the supplied buffer'
0142 self._bufferstartoffset=buf.getcurrentoffset()
0143 try: self.__field_command
0144 except:
0145 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+CGSN' })
0146 self.__field_command.writetobuffer(buf)
0147 self._bufferendoffset=buf.getcurrentoffset()
0148 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0149
0150
0151 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0152 'Reads this packet from the supplied buffer'
0153 self._bufferstartoffset=buf.getcurrentoffset()
0154 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0155 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+CGSN' })
0156 self.__field_command.readfrombuffer(buf)
0157 self._bufferendoffset=buf.getcurrentoffset()
0158
0159
0160 def __getfield_command(self):
0161 try: self.__field_command
0162 except:
0163 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+CGSN' })
0164 return self.__field_command.getvalue()
0165
0166 def __setfield_command(self, value):
0167 if isinstance(value,CSVSTRING):
0168 self.__field_command=value
0169 else:
0170 self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None, 'default': '+CGSN' })
0171
0172 def __delfield_command(self): del self.__field_command
0173
0174 command=property(__getfield_command, __setfield_command, __delfield_command, None)
0175
0176 def iscontainer(self):
0177 return True
0178
0179 def containerelements(self):
0180 yield ('command', self.__field_command, None)
0181
0182
0183
0184
0185 class esnresponse(BaseProtogenClass):
0186 __fields=['command', 'esnlabel', 'esn']
0187
0188 def __init__(self, *args, **kwargs):
0189 dict={}
0190 dict.update(kwargs)
0192 super(esnresponse,self).__init__(**dict)
0194 if self.__class__ is esnresponse:
0195 self._update(args,dict)
0196
0197
0198 def getfields(self):
0199 return self.__fields
0200
0201
0202 def _update(self, args, kwargs):
0203 super(esnresponse,self)._update(args,kwargs)
0204 keys=kwargs.keys()
0205 for key in keys:
0206 if key in self.__fields:
0207 setattr(self, key, kwargs[key])
0208 del kwargs[key]
0209 if __debug__:
0211 self._complainaboutunusedargs(esnresponse,kwargs)
0212 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0213
0215
0216 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0217 'Writes this packet to the supplied buffer'
0218 self._bufferstartoffset=buf.getcurrentoffset()
0219 self.__field_command.writetobuffer(buf)
0220 self.__field_esnlabel.writetobuffer(buf)
0221 self.__field_esn.writetobuffer(buf)
0222 self._bufferendoffset=buf.getcurrentoffset()
0223 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0224
0225
0226 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0227 'Reads this packet from the supplied buffer'
0228 self._bufferstartoffset=buf.getcurrentoffset()
0229 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0230 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': ord(' '), 'default': '+CGSN:' })
0231 self.__field_command.readfrombuffer(buf)
0232 self.__field_esnlabel=DATA(**{'sizeinbytes': 3})
0233 self.__field_esnlabel.readfrombuffer(buf)
0234 self.__field_esn=CSVSTRING(**{ 'quotechar': None, 'terminator': None })
0235 self.__field_esn.readfrombuffer(buf)
0236 self._bufferendoffset=buf.getcurrentoffset()
0237
0238
0239 def __getfield_command(self):
0240 return self.__field_command.getvalue()
0241
0242 def __setfield_command(self, value):
0243 if isinstance(value,CSVSTRING):
0244 self.__field_command=value
0245 else:
0246 self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': ord(' '), 'default': '+CGSN:' })
0247
0248 def __delfield_command(self): del self.__field_command
0249
0250 command=property(__getfield_command, __setfield_command, __delfield_command, None)
0251
0252 def __getfield_esnlabel(self):
0253 return self.__field_esnlabel.getvalue()
0254
0255 def __setfield_esnlabel(self, value):
0256 if isinstance(value,DATA):
0257 self.__field_esnlabel=value
0258 else:
0259 self.__field_esnlabel=DATA(value,**{'sizeinbytes': 3})
0260
0261 def __delfield_esnlabel(self): del self.__field_esnlabel
0262
0263 esnlabel=property(__getfield_esnlabel, __setfield_esnlabel, __delfield_esnlabel, None)
0264
0265 def __getfield_esn(self):
0266 return self.__field_esn.getvalue()
0267
0268 def __setfield_esn(self, value):
0269 if isinstance(value,CSVSTRING):
0270 self.__field_esn=value
0271 else:
0272 self.__field_esn=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None })
0273
0274 def __delfield_esn(self): del self.__field_esn
0275
0276 esn=property(__getfield_esn, __setfield_esn, __delfield_esn, None)
0277
0278 def iscontainer(self):
0279 return True
0280
0281 def containerelements(self):
0282 yield ('command', self.__field_command, None)
0283 yield ('esnlabel', self.__field_esnlabel, None)
0284 yield ('esn', self.__field_esn, None)
0285
0286
0287
0288
0289 class string_resp(BaseProtogenClass):
0290 __fields=['command', 'value']
0291
0292 def __init__(self, *args, **kwargs):
0293 dict={}
0294 dict.update(kwargs)
0296 super(string_resp,self).__init__(**dict)
0298 if self.__class__ is string_resp:
0299 self._update(args,dict)
0300
0301
0302 def getfields(self):
0303 return self.__fields
0304
0305
0306 def _update(self, args, kwargs):
0307 super(string_resp,self)._update(args,kwargs)
0308 keys=kwargs.keys()
0309 for key in keys:
0310 if key in self.__fields:
0311 setattr(self, key, kwargs[key])
0312 del kwargs[key]
0313 if __debug__:
0315 self._complainaboutunusedargs(string_resp,kwargs)
0316 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0317
0319
0320 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0321 'Writes this packet to the supplied buffer'
0322 self._bufferstartoffset=buf.getcurrentoffset()
0323 self.__field_command.writetobuffer(buf)
0324 self.__field_value.writetobuffer(buf)
0325 self._bufferendoffset=buf.getcurrentoffset()
0326 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0327
0328
0329 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0330 'Reads this packet from the supplied buffer'
0331 self._bufferstartoffset=buf.getcurrentoffset()
0332 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0333 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': ord(' ') })
0334 self.__field_command.readfrombuffer(buf)
0335 self.__field_value=CSVSTRING(**{ 'quotechar': None, 'terminator': None })
0336 self.__field_value.readfrombuffer(buf)
0337 self._bufferendoffset=buf.getcurrentoffset()
0338
0339
0340 def __getfield_command(self):
0341 return self.__field_command.getvalue()
0342
0343 def __setfield_command(self, value):
0344 if isinstance(value,CSVSTRING):
0345 self.__field_command=value
0346 else:
0347 self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': ord(' ') })
0348
0349 def __delfield_command(self): del self.__field_command
0350
0351 command=property(__getfield_command, __setfield_command, __delfield_command, None)
0352
0353 def __getfield_value(self):
0354 return self.__field_value.getvalue()
0355
0356 def __setfield_value(self, value):
0357 if isinstance(value,CSVSTRING):
0358 self.__field_value=value
0359 else:
0360 self.__field_value=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None })
0361
0362 def __delfield_value(self): del self.__field_value
0363
0364 value=property(__getfield_value, __setfield_value, __delfield_value, None)
0365
0366 def iscontainer(self):
0367 return True
0368
0369 def containerelements(self):
0370 yield ('command', self.__field_command, None)
0371 yield ('value', self.__field_value, None)
0372
0373
0374
0375
0376 class manufacturer_req(BaseProtogenClass):
0377 __fields=['command']
0378
0379 def __init__(self, *args, **kwargs):
0380 dict={}
0381 dict.update(kwargs)
0383 super(manufacturer_req,self).__init__(**dict)
0385 if self.__class__ is manufacturer_req:
0386 self._update(args,dict)
0387
0388
0389 def getfields(self):
0390 return self.__fields
0391
0392
0393 def _update(self, args, kwargs):
0394 super(manufacturer_req,self)._update(args,kwargs)
0395 keys=kwargs.keys()
0396 for key in keys:
0397 if key in self.__fields:
0398 setattr(self, key, kwargs[key])
0399 del kwargs[key]
0400 if __debug__:
0402 self._complainaboutunusedargs(manufacturer_req,kwargs)
0403 if len(args):
0404 dict2={ 'quotechar': None, 'terminator': None, 'default': '+GMI' }
0405 dict2.update(kwargs)
0406 kwargs=dict2
0407 self.__field_command=CSVSTRING(*args,**dict2)
0408
0410
0411 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0412 'Writes this packet to the supplied buffer'
0413 self._bufferstartoffset=buf.getcurrentoffset()
0414 try: self.__field_command
0415 except:
0416 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+GMI' })
0417 self.__field_command.writetobuffer(buf)
0418 self._bufferendoffset=buf.getcurrentoffset()
0419 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0420
0421
0422 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0423 'Reads this packet from the supplied buffer'
0424 self._bufferstartoffset=buf.getcurrentoffset()
0425 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0426 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+GMI' })
0427 self.__field_command.readfrombuffer(buf)
0428 self._bufferendoffset=buf.getcurrentoffset()
0429
0430
0431 def __getfield_command(self):
0432 try: self.__field_command
0433 except:
0434 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+GMI' })
0435 return self.__field_command.getvalue()
0436
0437 def __setfield_command(self, value):
0438 if isinstance(value,CSVSTRING):
0439 self.__field_command=value
0440 else:
0441 self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None, 'default': '+GMI' })
0442
0443 def __delfield_command(self): del self.__field_command
0444
0445 command=property(__getfield_command, __setfield_command, __delfield_command, None)
0446
0447 def iscontainer(self):
0448 return True
0449
0450 def containerelements(self):
0451 yield ('command', self.__field_command, None)
0452
0453
0454
0455
0456 class model_req(BaseProtogenClass):
0457 __fields=['command']
0458
0459 def __init__(self, *args, **kwargs):
0460 dict={}
0461 dict.update(kwargs)
0463 super(model_req,self).__init__(**dict)
0465 if self.__class__ is model_req:
0466 self._update(args,dict)
0467
0468
0469 def getfields(self):
0470 return self.__fields
0471
0472
0473 def _update(self, args, kwargs):
0474 super(model_req,self)._update(args,kwargs)
0475 keys=kwargs.keys()
0476 for key in keys:
0477 if key in self.__fields:
0478 setattr(self, key, kwargs[key])
0479 del kwargs[key]
0480 if __debug__:
0482 self._complainaboutunusedargs(model_req,kwargs)
0483 if len(args):
0484 dict2={ 'quotechar': None, 'terminator': None, 'default': '+GMM' }
0485 dict2.update(kwargs)
0486 kwargs=dict2
0487 self.__field_command=CSVSTRING(*args,**dict2)
0488
0490
0491 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0492 'Writes this packet to the supplied buffer'
0493 self._bufferstartoffset=buf.getcurrentoffset()
0494 try: self.__field_command
0495 except:
0496 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+GMM' })
0497 self.__field_command.writetobuffer(buf)
0498 self._bufferendoffset=buf.getcurrentoffset()
0499 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0500
0501
0502 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0503 'Reads this packet from the supplied buffer'
0504 self._bufferstartoffset=buf.getcurrentoffset()
0505 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0506 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+GMM' })
0507 self.__field_command.readfrombuffer(buf)
0508 self._bufferendoffset=buf.getcurrentoffset()
0509
0510
0511 def __getfield_command(self):
0512 try: self.__field_command
0513 except:
0514 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+GMM' })
0515 return self.__field_command.getvalue()
0516
0517 def __setfield_command(self, value):
0518 if isinstance(value,CSVSTRING):
0519 self.__field_command=value
0520 else:
0521 self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None, 'default': '+GMM' })
0522
0523 def __delfield_command(self): del self.__field_command
0524
0525 command=property(__getfield_command, __setfield_command, __delfield_command, None)
0526
0527 def iscontainer(self):
0528 return True
0529
0530 def containerelements(self):
0531 yield ('command', self.__field_command, None)
0532
0533
0534
0535
0536 class number_req(BaseProtogenClass):
0537 __fields=['command']
0538
0539 def __init__(self, *args, **kwargs):
0540 dict={}
0541 dict.update(kwargs)
0543 super(number_req,self).__init__(**dict)
0545 if self.__class__ is number_req:
0546 self._update(args,dict)
0547
0548
0549 def getfields(self):
0550 return self.__fields
0551
0552
0553 def _update(self, args, kwargs):
0554 super(number_req,self)._update(args,kwargs)
0555 keys=kwargs.keys()
0556 for key in keys:
0557 if key in self.__fields:
0558 setattr(self, key, kwargs[key])
0559 del kwargs[key]
0560 if __debug__:
0562 self._complainaboutunusedargs(number_req,kwargs)
0563 if len(args):
0564 dict2={ 'quotechar': None, 'terminator': None, 'default': '+CNUM' }
0565 dict2.update(kwargs)
0566 kwargs=dict2
0567 self.__field_command=CSVSTRING(*args,**dict2)
0568
0570
0571 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0572 'Writes this packet to the supplied buffer'
0573 self._bufferstartoffset=buf.getcurrentoffset()
0574 try: self.__field_command
0575 except:
0576 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+CNUM' })
0577 self.__field_command.writetobuffer(buf)
0578 self._bufferendoffset=buf.getcurrentoffset()
0579 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0580
0581
0582 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0583 'Reads this packet from the supplied buffer'
0584 self._bufferstartoffset=buf.getcurrentoffset()
0585 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0586 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+CNUM' })
0587 self.__field_command.readfrombuffer(buf)
0588 self._bufferendoffset=buf.getcurrentoffset()
0589
0590
0591 def __getfield_command(self):
0592 try: self.__field_command
0593 except:
0594 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+CNUM' })
0595 return self.__field_command.getvalue()
0596
0597 def __setfield_command(self, value):
0598 if isinstance(value,CSVSTRING):
0599 self.__field_command=value
0600 else:
0601 self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None, 'default': '+CNUM' })
0602
0603 def __delfield_command(self): del self.__field_command
0604
0605 command=property(__getfield_command, __setfield_command, __delfield_command, None)
0606
0607 def iscontainer(self):
0608 return True
0609
0610 def containerelements(self):
0611 yield ('command', self.__field_command, None)
0612
0613
0614
0615
0616 class firmware_req(BaseProtogenClass):
0617 __fields=['command']
0618
0619 def __init__(self, *args, **kwargs):
0620 dict={}
0621 dict.update(kwargs)
0623 super(firmware_req,self).__init__(**dict)
0625 if self.__class__ is firmware_req:
0626 self._update(args,dict)
0627
0628
0629 def getfields(self):
0630 return self.__fields
0631
0632
0633 def _update(self, args, kwargs):
0634 super(firmware_req,self)._update(args,kwargs)
0635 keys=kwargs.keys()
0636 for key in keys:
0637 if key in self.__fields:
0638 setattr(self, key, kwargs[key])
0639 del kwargs[key]
0640 if __debug__:
0642 self._complainaboutunusedargs(firmware_req,kwargs)
0643 if len(args):
0644 dict2={ 'quotechar': None, 'terminator': None, 'default': '+GMR' }
0645 dict2.update(kwargs)
0646 kwargs=dict2
0647 self.__field_command=CSVSTRING(*args,**dict2)
0648
0650
0651 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0652 'Writes this packet to the supplied buffer'
0653 self._bufferstartoffset=buf.getcurrentoffset()
0654 try: self.__field_command
0655 except:
0656 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+GMR' })
0657 self.__field_command.writetobuffer(buf)
0658 self._bufferendoffset=buf.getcurrentoffset()
0659 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0660
0661
0662 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0663 'Reads this packet from the supplied buffer'
0664 self._bufferstartoffset=buf.getcurrentoffset()
0665 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0666 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+GMR' })
0667 self.__field_command.readfrombuffer(buf)
0668 self._bufferendoffset=buf.getcurrentoffset()
0669
0670
0671 def __getfield_command(self):
0672 try: self.__field_command
0673 except:
0674 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+GMR' })
0675 return self.__field_command.getvalue()
0676
0677 def __setfield_command(self, value):
0678 if isinstance(value,CSVSTRING):
0679 self.__field_command=value
0680 else:
0681 self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None, 'default': '+GMR' })
0682
0683 def __delfield_command(self): del self.__field_command
0684
0685 command=property(__getfield_command, __setfield_command, __delfield_command, None)
0686
0687 def iscontainer(self):
0688 return True
0689
0690 def containerelements(self):
0691 yield ('command', self.__field_command, None)
0692
0693
0694
0695
0696 class signal_req(BaseProtogenClass):
0697 __fields=['command']
0698
0699 def __init__(self, *args, **kwargs):
0700 dict={}
0701 dict.update(kwargs)
0703 super(signal_req,self).__init__(**dict)
0705 if self.__class__ is signal_req:
0706 self._update(args,dict)
0707
0708
0709 def getfields(self):
0710 return self.__fields
0711
0712
0713 def _update(self, args, kwargs):
0714 super(signal_req,self)._update(args,kwargs)
0715 keys=kwargs.keys()
0716 for key in keys:
0717 if key in self.__fields:
0718 setattr(self, key, kwargs[key])
0719 del kwargs[key]
0720 if __debug__:
0722 self._complainaboutunusedargs(signal_req,kwargs)
0723 if len(args):
0724 dict2={ 'quotechar': None, 'terminator': None, 'default': '+CSQ?' }
0725 dict2.update(kwargs)
0726 kwargs=dict2
0727 self.__field_command=CSVSTRING(*args,**dict2)
0728
0730
0731 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0732 'Writes this packet to the supplied buffer'
0733 self._bufferstartoffset=buf.getcurrentoffset()
0734 try: self.__field_command
0735 except:
0736 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+CSQ?' })
0737 self.__field_command.writetobuffer(buf)
0738 self._bufferendoffset=buf.getcurrentoffset()
0739 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0740
0741
0742 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0743 'Reads this packet from the supplied buffer'
0744 self._bufferstartoffset=buf.getcurrentoffset()
0745 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0746 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+CSQ?' })
0747 self.__field_command.readfrombuffer(buf)
0748 self._bufferendoffset=buf.getcurrentoffset()
0749
0750
0751 def __getfield_command(self):
0752 try: self.__field_command
0753 except:
0754 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+CSQ?' })
0755 return self.__field_command.getvalue()
0756
0757 def __setfield_command(self, value):
0758 if isinstance(value,CSVSTRING):
0759 self.__field_command=value
0760 else:
0761 self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None, 'default': '+CSQ?' })
0762
0763 def __delfield_command(self): del self.__field_command
0764
0765 command=property(__getfield_command, __setfield_command, __delfield_command, None)
0766
0767 def iscontainer(self):
0768 return True
0769
0770 def containerelements(self):
0771 yield ('command', self.__field_command, None)
0772
0773
0774
0775
0776 class signal_resp(BaseProtogenClass):
0777 __fields=['command', 'rssi', 'ber']
0778
0779 def __init__(self, *args, **kwargs):
0780 dict={}
0781 dict.update(kwargs)
0783 super(signal_resp,self).__init__(**dict)
0785 if self.__class__ is signal_resp:
0786 self._update(args,dict)
0787
0788
0789 def getfields(self):
0790 return self.__fields
0791
0792
0793 def _update(self, args, kwargs):
0794 super(signal_resp,self)._update(args,kwargs)
0795 keys=kwargs.keys()
0796 for key in keys:
0797 if key in self.__fields:
0798 setattr(self, key, kwargs[key])
0799 del kwargs[key]
0800 if __debug__:
0802 self._complainaboutunusedargs(signal_resp,kwargs)
0803 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0804
0806
0807 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0808 'Writes this packet to the supplied buffer'
0809 self._bufferstartoffset=buf.getcurrentoffset()
0810 self.__field_command.writetobuffer(buf)
0811 self.__field_rssi.writetobuffer(buf)
0812 self.__field_ber.writetobuffer(buf)
0813 self._bufferendoffset=buf.getcurrentoffset()
0814 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0815
0816
0817 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0818 'Reads this packet from the supplied buffer'
0819 self._bufferstartoffset=buf.getcurrentoffset()
0820 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0821 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': ord(' ') })
0822 self.__field_command.readfrombuffer(buf)
0823 self.__field_rssi=CSVINT()
0824 self.__field_rssi.readfrombuffer(buf)
0825 self.__field_ber=CSVINT(**{ 'terminator': None })
0826 self.__field_ber.readfrombuffer(buf)
0827 self._bufferendoffset=buf.getcurrentoffset()
0828
0829
0830 def __getfield_command(self):
0831 return self.__field_command.getvalue()
0832
0833 def __setfield_command(self, value):
0834 if isinstance(value,CSVSTRING):
0835 self.__field_command=value
0836 else:
0837 self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': ord(' ') })
0838
0839 def __delfield_command(self): del self.__field_command
0840
0841 command=property(__getfield_command, __setfield_command, __delfield_command, None)
0842
0843 def __getfield_rssi(self):
0844 return self.__field_rssi.getvalue()
0845
0846 def __setfield_rssi(self, value):
0847 if isinstance(value,CSVINT):
0848 self.__field_rssi=value
0849 else:
0850 self.__field_rssi=CSVINT(value,)
0851
0852 def __delfield_rssi(self): del self.__field_rssi
0853
0854 rssi=property(__getfield_rssi, __setfield_rssi, __delfield_rssi, None)
0855
0856 def __getfield_ber(self):
0857 return self.__field_ber.getvalue()
0858
0859 def __setfield_ber(self, value):
0860 if isinstance(value,CSVINT):
0861 self.__field_ber=value
0862 else:
0863 self.__field_ber=CSVINT(value,**{ 'terminator': None })
0864
0865 def __delfield_ber(self): del self.__field_ber
0866
0867 ber=property(__getfield_ber, __setfield_ber, __delfield_ber, None)
0868
0869 def iscontainer(self):
0870 return True
0871
0872 def containerelements(self):
0873 yield ('command', self.__field_command, None)
0874 yield ('rssi', self.__field_rssi, None)
0875 yield ('ber', self.__field_ber, None)
0876
0877
0878
0879
0880 class battery_req(BaseProtogenClass):
0881 __fields=['command']
0882
0883 def __init__(self, *args, **kwargs):
0884 dict={}
0885 dict.update(kwargs)
0887 super(battery_req,self).__init__(**dict)
0889 if self.__class__ is battery_req:
0890 self._update(args,dict)
0891
0892
0893 def getfields(self):
0894 return self.__fields
0895
0896
0897 def _update(self, args, kwargs):
0898 super(battery_req,self)._update(args,kwargs)
0899 keys=kwargs.keys()
0900 for key in keys:
0901 if key in self.__fields:
0902 setattr(self, key, kwargs[key])
0903 del kwargs[key]
0904 if __debug__:
0906 self._complainaboutunusedargs(battery_req,kwargs)
0907 if len(args):
0908 dict2={ 'quotechar': None, 'terminator': None, 'default': '+CBC' }
0909 dict2.update(kwargs)
0910 kwargs=dict2
0911 self.__field_command=CSVSTRING(*args,**dict2)
0912
0914
0915 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0916 'Writes this packet to the supplied buffer'
0917 self._bufferstartoffset=buf.getcurrentoffset()
0918 try: self.__field_command
0919 except:
0920 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+CBC' })
0921 self.__field_command.writetobuffer(buf)
0922 self._bufferendoffset=buf.getcurrentoffset()
0923 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0924
0925
0926 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0927 'Reads this packet from the supplied buffer'
0928 self._bufferstartoffset=buf.getcurrentoffset()
0929 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0930 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+CBC' })
0931 self.__field_command.readfrombuffer(buf)
0932 self._bufferendoffset=buf.getcurrentoffset()
0933
0934
0935 def __getfield_command(self):
0936 try: self.__field_command
0937 except:
0938 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+CBC' })
0939 return self.__field_command.getvalue()
0940
0941 def __setfield_command(self, value):
0942 if isinstance(value,CSVSTRING):
0943 self.__field_command=value
0944 else:
0945 self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None, 'default': '+CBC' })
0946
0947 def __delfield_command(self): del self.__field_command
0948
0949 command=property(__getfield_command, __setfield_command, __delfield_command, None)
0950
0951 def iscontainer(self):
0952 return True
0953
0954 def containerelements(self):
0955 yield ('command', self.__field_command, None)
0956
0957
0958
0959
0960 class battery_resp(BaseProtogenClass):
0961 __fields=['command', 'status', 'level']
0962
0963 def __init__(self, *args, **kwargs):
0964 dict={}
0965 dict.update(kwargs)
0967 super(battery_resp,self).__init__(**dict)
0969 if self.__class__ is battery_resp:
0970 self._update(args,dict)
0971
0972
0973 def getfields(self):
0974 return self.__fields
0975
0976
0977 def _update(self, args, kwargs):
0978 super(battery_resp,self)._update(args,kwargs)
0979 keys=kwargs.keys()
0980 for key in keys:
0981 if key in self.__fields:
0982 setattr(self, key, kwargs[key])
0983 del kwargs[key]
0984 if __debug__:
0986 self._complainaboutunusedargs(battery_resp,kwargs)
0987 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0988
0990
0991 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0992 'Writes this packet to the supplied buffer'
0993 self._bufferstartoffset=buf.getcurrentoffset()
0994 self.__field_command.writetobuffer(buf)
0995 self.__field_status.writetobuffer(buf)
0996 self.__field_level.writetobuffer(buf)
0997 self._bufferendoffset=buf.getcurrentoffset()
0998 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0999
1000
1001 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1002 'Reads this packet from the supplied buffer'
1003 self._bufferstartoffset=buf.getcurrentoffset()
1004 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1005 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': ord(' ') })
1006 self.__field_command.readfrombuffer(buf)
1007 self.__field_status=CSVINT()
1008 self.__field_status.readfrombuffer(buf)
1009 self.__field_level=CSVINT(**{ 'terminator': None })
1010 self.__field_level.readfrombuffer(buf)
1011 self._bufferendoffset=buf.getcurrentoffset()
1012
1013
1014 def __getfield_command(self):
1015 return self.__field_command.getvalue()
1016
1017 def __setfield_command(self, value):
1018 if isinstance(value,CSVSTRING):
1019 self.__field_command=value
1020 else:
1021 self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': ord(' ') })
1022
1023 def __delfield_command(self): del self.__field_command
1024
1025 command=property(__getfield_command, __setfield_command, __delfield_command, None)
1026
1027 def __getfield_status(self):
1028 return self.__field_status.getvalue()
1029
1030 def __setfield_status(self, value):
1031 if isinstance(value,CSVINT):
1032 self.__field_status=value
1033 else:
1034 self.__field_status=CSVINT(value,)
1035
1036 def __delfield_status(self): del self.__field_status
1037
1038 status=property(__getfield_status, __setfield_status, __delfield_status, None)
1039
1040 def __getfield_level(self):
1041 return self.__field_level.getvalue()
1042
1043 def __setfield_level(self, value):
1044 if isinstance(value,CSVINT):
1045 self.__field_level=value
1046 else:
1047 self.__field_level=CSVINT(value,**{ 'terminator': None })
1048
1049 def __delfield_level(self): del self.__field_level
1050
1051 level=property(__getfield_level, __setfield_level, __delfield_level, None)
1052
1053 def iscontainer(self):
1054 return True
1055
1056 def containerelements(self):
1057 yield ('command', self.__field_command, None)
1058 yield ('status', self.__field_status, None)
1059 yield ('level', self.__field_level, None)
1060
1061
1062
1063
1064 class modereq(BaseProtogenClass):
1065 __fields=['command']
1066
1067 def __init__(self, *args, **kwargs):
1068 dict={}
1069 dict.update(kwargs)
1071 super(modereq,self).__init__(**dict)
1073 if self.__class__ is modereq:
1074 self._update(args,dict)
1075
1076
1077 def getfields(self):
1078 return self.__fields
1079
1080
1081 def _update(self, args, kwargs):
1082 super(modereq,self)._update(args,kwargs)
1083 keys=kwargs.keys()
1084 for key in keys:
1085 if key in self.__fields:
1086 setattr(self, key, kwargs[key])
1087 del kwargs[key]
1088 if __debug__:
1090 self._complainaboutunusedargs(modereq,kwargs)
1091 if len(args):
1092 dict2={ 'quotechar': None, 'terminator': None, 'default': '+MODE?' }
1093 dict2.update(kwargs)
1094 kwargs=dict2
1095 self.__field_command=CSVSTRING(*args,**dict2)
1096
1098
1099 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1100 'Writes this packet to the supplied buffer'
1101 self._bufferstartoffset=buf.getcurrentoffset()
1102 try: self.__field_command
1103 except:
1104 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+MODE?' })
1105 self.__field_command.writetobuffer(buf)
1106 self._bufferendoffset=buf.getcurrentoffset()
1107 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1108
1109
1110 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1111 'Reads this packet from the supplied buffer'
1112 self._bufferstartoffset=buf.getcurrentoffset()
1113 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1114 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+MODE?' })
1115 self.__field_command.readfrombuffer(buf)
1116 self._bufferendoffset=buf.getcurrentoffset()
1117
1118
1119 def __getfield_command(self):
1120 try: self.__field_command
1121 except:
1122 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+MODE?' })
1123 return self.__field_command.getvalue()
1124
1125 def __setfield_command(self, value):
1126 if isinstance(value,CSVSTRING):
1127 self.__field_command=value
1128 else:
1129 self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None, 'default': '+MODE?' })
1130
1131 def __delfield_command(self): del self.__field_command
1132
1133 command=property(__getfield_command, __setfield_command, __delfield_command, None)
1134
1135 def iscontainer(self):
1136 return True
1137
1138 def containerelements(self):
1139 yield ('command', self.__field_command, None)
1140
1141
1142
1143
1144 class moderesp(BaseProtogenClass):
1145 __fields=['command', 'mode']
1146
1147 def __init__(self, *args, **kwargs):
1148 dict={}
1149 dict.update(kwargs)
1151 super(moderesp,self).__init__(**dict)
1153 if self.__class__ is moderesp:
1154 self._update(args,dict)
1155
1156
1157 def getfields(self):
1158 return self.__fields
1159
1160
1161 def _update(self, args, kwargs):
1162 super(moderesp,self)._update(args,kwargs)
1163 keys=kwargs.keys()
1164 for key in keys:
1165 if key in self.__fields:
1166 setattr(self, key, kwargs[key])
1167 del kwargs[key]
1168 if __debug__:
1170 self._complainaboutunusedargs(moderesp,kwargs)
1171 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1172
1174
1175 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1176 'Writes this packet to the supplied buffer'
1177 self._bufferstartoffset=buf.getcurrentoffset()
1178 self.__field_command.writetobuffer(buf)
1179 self.__field_mode.writetobuffer(buf)
1180 self._bufferendoffset=buf.getcurrentoffset()
1181 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1182
1183
1184 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1185 'Reads this packet from the supplied buffer'
1186 self._bufferstartoffset=buf.getcurrentoffset()
1187 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1188 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': ord(' '), 'default': '+MODE:' })
1189 self.__field_command.readfrombuffer(buf)
1190 self.__field_mode=CSVINT(**{ 'terminator': None })
1191 self.__field_mode.readfrombuffer(buf)
1192 self._bufferendoffset=buf.getcurrentoffset()
1193
1194
1195 def __getfield_command(self):
1196 return self.__field_command.getvalue()
1197
1198 def __setfield_command(self, value):
1199 if isinstance(value,CSVSTRING):
1200 self.__field_command=value
1201 else:
1202 self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': ord(' '), 'default': '+MODE:' })
1203
1204 def __delfield_command(self): del self.__field_command
1205
1206 command=property(__getfield_command, __setfield_command, __delfield_command, None)
1207
1208 def __getfield_mode(self):
1209 return self.__field_mode.getvalue()
1210
1211 def __setfield_mode(self, value):
1212 if isinstance(value,CSVINT):
1213 self.__field_mode=value
1214 else:
1215 self.__field_mode=CSVINT(value,**{ 'terminator': None })
1216
1217 def __delfield_mode(self): del self.__field_mode
1218
1219 mode=property(__getfield_mode, __setfield_mode, __delfield_mode, None)
1220
1221 def iscontainer(self):
1222 return True
1223
1224 def containerelements(self):
1225 yield ('command', self.__field_command, None)
1226 yield ('mode', self.__field_mode, None)
1227
1228
1229
1230
1231 class modeset(BaseProtogenClass):
1232 __fields=['command', 'mode']
1233
1234 def __init__(self, *args, **kwargs):
1235 dict={}
1236 dict.update(kwargs)
1238 super(modeset,self).__init__(**dict)
1240 if self.__class__ is modeset:
1241 self._update(args,dict)
1242
1243
1244 def getfields(self):
1245 return self.__fields
1246
1247
1248 def _update(self, args, kwargs):
1249 super(modeset,self)._update(args,kwargs)
1250 keys=kwargs.keys()
1251 for key in keys:
1252 if key in self.__fields:
1253 setattr(self, key, kwargs[key])
1254 del kwargs[key]
1255 if __debug__:
1257 self._complainaboutunusedargs(modeset,kwargs)
1258 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1259
1261
1262 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1263 'Writes this packet to the supplied buffer'
1264 self._bufferstartoffset=buf.getcurrentoffset()
1265 try: self.__field_command
1266 except:
1267 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+MODE=' })
1268 self.__field_command.writetobuffer(buf)
1269 try: self.__field_mode
1270 except:
1271 self.__field_mode=CSVINT(**{ 'terminator': None, 'default': 0 })
1272 self.__field_mode.writetobuffer(buf)
1273 self._bufferendoffset=buf.getcurrentoffset()
1274 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1275
1276
1277 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1278 'Reads this packet from the supplied buffer'
1279 self._bufferstartoffset=buf.getcurrentoffset()
1280 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1281 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+MODE=' })
1282 self.__field_command.readfrombuffer(buf)
1283 self.__field_mode=CSVINT(**{ 'terminator': None, 'default': 0 })
1284 self.__field_mode.readfrombuffer(buf)
1285 self._bufferendoffset=buf.getcurrentoffset()
1286
1287
1288 def __getfield_command(self):
1289 try: self.__field_command
1290 except:
1291 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+MODE=' })
1292 return self.__field_command.getvalue()
1293
1294 def __setfield_command(self, value):
1295 if isinstance(value,CSVSTRING):
1296 self.__field_command=value
1297 else:
1298 self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None, 'default': '+MODE=' })
1299
1300 def __delfield_command(self): del self.__field_command
1301
1302 command=property(__getfield_command, __setfield_command, __delfield_command, None)
1303
1304 def __getfield_mode(self):
1305 try: self.__field_mode
1306 except:
1307 self.__field_mode=CSVINT(**{ 'terminator': None, 'default': 0 })
1308 return self.__field_mode.getvalue()
1309
1310 def __setfield_mode(self, value):
1311 if isinstance(value,CSVINT):
1312 self.__field_mode=value
1313 else:
1314 self.__field_mode=CSVINT(value,**{ 'terminator': None, 'default': 0 })
1315
1316 def __delfield_mode(self): del self.__field_mode
1317
1318 mode=property(__getfield_mode, __setfield_mode, __delfield_mode, None)
1319
1320 def iscontainer(self):
1321 return True
1322
1323 def containerelements(self):
1324 yield ('command', self.__field_command, None)
1325 yield ('mode', self.__field_mode, None)
1326
1327
1328
1329
1330 class charset_set_req(BaseProtogenClass):
1331 __fields=['command', 'charset']
1332
1333 def __init__(self, *args, **kwargs):
1334 dict={}
1335 dict.update(kwargs)
1337 super(charset_set_req,self).__init__(**dict)
1339 if self.__class__ is charset_set_req:
1340 self._update(args,dict)
1341
1342
1343 def getfields(self):
1344 return self.__fields
1345
1346
1347 def _update(self, args, kwargs):
1348 super(charset_set_req,self)._update(args,kwargs)
1349 keys=kwargs.keys()
1350 for key in keys:
1351 if key in self.__fields:
1352 setattr(self, key, kwargs[key])
1353 del kwargs[key]
1354 if __debug__:
1356 self._complainaboutunusedargs(charset_set_req,kwargs)
1357 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1358
1360
1361 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1362 'Writes this packet to the supplied buffer'
1363 self._bufferstartoffset=buf.getcurrentoffset()
1364 try: self.__field_command
1365 except:
1366 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+CSCS=' })
1367 self.__field_command.writetobuffer(buf)
1368 try: self.__field_charset
1369 except:
1370 self.__field_charset=CSVSTRING(**{ 'terminator': None })
1371 self.__field_charset.writetobuffer(buf)
1372 self._bufferendoffset=buf.getcurrentoffset()
1373 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1374
1375
1376 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1377 'Reads this packet from the supplied buffer'
1378 self._bufferstartoffset=buf.getcurrentoffset()
1379 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1380 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+CSCS=' })
1381 self.__field_command.readfrombuffer(buf)
1382 self.__field_charset=CSVSTRING(**{ 'terminator': None })
1383 self.__field_charset.readfrombuffer(buf)
1384 self._bufferendoffset=buf.getcurrentoffset()
1385
1386
1387 def __getfield_command(self):
1388 try: self.__field_command
1389 except:
1390 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+CSCS=' })
1391 return self.__field_command.getvalue()
1392
1393 def __setfield_command(self, value):
1394 if isinstance(value,CSVSTRING):
1395 self.__field_command=value
1396 else:
1397 self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None, 'default': '+CSCS=' })
1398
1399 def __delfield_command(self): del self.__field_command
1400
1401 command=property(__getfield_command, __setfield_command, __delfield_command, None)
1402
1403 def __getfield_charset(self):
1404 try: self.__field_charset
1405 except:
1406 self.__field_charset=CSVSTRING(**{ 'terminator': None })
1407 return self.__field_charset.getvalue()
1408
1409 def __setfield_charset(self, value):
1410 if isinstance(value,CSVSTRING):
1411 self.__field_charset=value
1412 else:
1413 self.__field_charset=CSVSTRING(value,**{ 'terminator': None })
1414
1415 def __delfield_charset(self): del self.__field_charset
1416
1417 charset=property(__getfield_charset, __setfield_charset, __delfield_charset, None)
1418
1419 def iscontainer(self):
1420 return True
1421
1422 def containerelements(self):
1423 yield ('command', self.__field_command, None)
1424 yield ('charset', self.__field_charset, None)
1425
1426
1427
1428
1429 class featurereq(BaseProtogenClass):
1430 __fields=['command']
1431
1432 def __init__(self, *args, **kwargs):
1433 dict={}
1434 dict.update(kwargs)
1436 super(featurereq,self).__init__(**dict)
1438 if self.__class__ is featurereq:
1439 self._update(args,dict)
1440
1441
1442 def getfields(self):
1443 return self.__fields
1444
1445
1446 def _update(self, args, kwargs):
1447 super(featurereq,self)._update(args,kwargs)
1448 keys=kwargs.keys()
1449 for key in keys:
1450 if key in self.__fields:
1451 setattr(self, key, kwargs[key])
1452 del kwargs[key]
1453 if __debug__:
1455 self._complainaboutunusedargs(featurereq,kwargs)
1456 if len(args):
1457 dict2={ 'quotechar': None, 'terminator': None, 'default': '+MAID?' }
1458 dict2.update(kwargs)
1459 kwargs=dict2
1460 self.__field_command=CSVSTRING(*args,**dict2)
1461
1463
1464 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1465 'Writes this packet to the supplied buffer'
1466 self._bufferstartoffset=buf.getcurrentoffset()
1467 try: self.__field_command
1468 except:
1469 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+MAID?' })
1470 self.__field_command.writetobuffer(buf)
1471 self._bufferendoffset=buf.getcurrentoffset()
1472 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1473
1474
1475 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1476 'Reads this packet from the supplied buffer'
1477 self._bufferstartoffset=buf.getcurrentoffset()
1478 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1479 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+MAID?' })
1480 self.__field_command.readfrombuffer(buf)
1481 self._bufferendoffset=buf.getcurrentoffset()
1482
1483
1484 def __getfield_command(self):
1485 try: self.__field_command
1486 except:
1487 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+MAID?' })
1488 return self.__field_command.getvalue()
1489
1490 def __setfield_command(self, value):
1491 if isinstance(value,CSVSTRING):
1492 self.__field_command=value
1493 else:
1494 self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None, 'default': '+MAID?' })
1495
1496 def __delfield_command(self): del self.__field_command
1497
1498 command=property(__getfield_command, __setfield_command, __delfield_command, None)
1499
1500 def iscontainer(self):
1501 return True
1502
1503 def containerelements(self):
1504 yield ('command', self.__field_command, None)
1505
1506
1507
1508
1509 class featureresp(BaseProtogenClass):
1510 __fields=['command', 'has_phonebook', 'has_datebook', 'has_sms', 'has_mo_sms', 'has_email', 'has_multi_phonebooks', 'has_sim', 'has_shared_phonebook', 'has_multi_dest_addr', 'has_ringtone_id', 'has_voicetag', 'dunno']
1511
1512 def __init__(self, *args, **kwargs):
1513 dict={}
1514 dict.update(kwargs)
1516 super(featureresp,self).__init__(**dict)
1518 if self.__class__ is featureresp:
1519 self._update(args,dict)
1520
1521
1522 def getfields(self):
1523 return self.__fields
1524
1525
1526 def _update(self, args, kwargs):
1527 super(featureresp,self)._update(args,kwargs)
1528 keys=kwargs.keys()
1529 for key in keys:
1530 if key in self.__fields:
1531 setattr(self, key, kwargs[key])
1532 del kwargs[key]
1533 if __debug__:
1535 self._complainaboutunusedargs(featureresp,kwargs)
1536 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1537
1539
1540 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1541 'Writes this packet to the supplied buffer'
1542 self._bufferstartoffset=buf.getcurrentoffset()
1543 self.__field_command.writetobuffer(buf)
1544 self.__field_has_phonebook.writetobuffer(buf)
1545 self.__field_has_datebook.writetobuffer(buf)
1546 self.__field_has_sms.writetobuffer(buf)
1547 self.__field_has_mo_sms.writetobuffer(buf)
1548 self.__field_has_email.writetobuffer(buf)
1549 self.__field_has_multi_phonebooks.writetobuffer(buf)
1550 self.__field_has_sim.writetobuffer(buf)
1551 self.__field_has_shared_phonebook.writetobuffer(buf)
1552 self.__field_has_multi_dest_addr.writetobuffer(buf)
1553 self.__field_has_ringtone_id.writetobuffer(buf)
1554 self.__field_has_voicetag.writetobuffer(buf)
1555 try: self.__field_dunno
1556 except:
1557 self.__field_dunno=CSVSTRING(**{ 'quotechar': None, 'terminator': None })
1558 self.__field_dunno.writetobuffer(buf)
1559 self._bufferendoffset=buf.getcurrentoffset()
1560 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1561
1562
1563 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1564 'Reads this packet from the supplied buffer'
1565 self._bufferstartoffset=buf.getcurrentoffset()
1566 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1567 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': ord(' '), 'default': '+MAID:' })
1568 self.__field_command.readfrombuffer(buf)
1569 self.__field_has_phonebook=CSVINT()
1570 self.__field_has_phonebook.readfrombuffer(buf)
1571 self.__field_has_datebook=CSVINT()
1572 self.__field_has_datebook.readfrombuffer(buf)
1573 self.__field_has_sms=CSVINT()
1574 self.__field_has_sms.readfrombuffer(buf)
1575 self.__field_has_mo_sms=CSVINT()
1576 self.__field_has_mo_sms.readfrombuffer(buf)
1577 self.__field_has_email=CSVINT()
1578 self.__field_has_email.readfrombuffer(buf)
1579 self.__field_has_multi_phonebooks=CSVINT()
1580 self.__field_has_multi_phonebooks.readfrombuffer(buf)
1581 self.__field_has_sim=CSVINT()
1582 self.__field_has_sim.readfrombuffer(buf)
1583 self.__field_has_shared_phonebook=CSVINT()
1584 self.__field_has_shared_phonebook.readfrombuffer(buf)
1585 self.__field_has_multi_dest_addr=CSVINT()
1586 self.__field_has_multi_dest_addr.readfrombuffer(buf)
1587 self.__field_has_ringtone_id=CSVINT()
1588 self.__field_has_ringtone_id.readfrombuffer(buf)
1589 self.__field_has_voicetag=CSVINT()
1590 self.__field_has_voicetag.readfrombuffer(buf)
1591 self.__field_dunno=CSVSTRING(**{ 'quotechar': None, 'terminator': None })
1592 self.__field_dunno.readfrombuffer(buf)
1593 self._bufferendoffset=buf.getcurrentoffset()
1594
1595
1596 def __getfield_command(self):
1597 return self.__field_command.getvalue()
1598
1599 def __setfield_command(self, value):
1600 if isinstance(value,CSVSTRING):
1601 self.__field_command=value
1602 else:
1603 self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': ord(' '), 'default': '+MAID:' })
1604
1605 def __delfield_command(self): del self.__field_command
1606
1607 command=property(__getfield_command, __setfield_command, __delfield_command, None)
1608
1609 def __getfield_has_phonebook(self):
1610 return self.__field_has_phonebook.getvalue()
1611
1612 def __setfield_has_phonebook(self, value):
1613 if isinstance(value,CSVINT):
1614 self.__field_has_phonebook=value
1615 else:
1616 self.__field_has_phonebook=CSVINT(value,)
1617
1618 def __delfield_has_phonebook(self): del self.__field_has_phonebook
1619
1620 has_phonebook=property(__getfield_has_phonebook, __setfield_has_phonebook, __delfield_has_phonebook, None)
1621
1622 def __getfield_has_datebook(self):
1623 return self.__field_has_datebook.getvalue()
1624
1625 def __setfield_has_datebook(self, value):
1626 if isinstance(value,CSVINT):
1627 self.__field_has_datebook=value
1628 else:
1629 self.__field_has_datebook=CSVINT(value,)
1630
1631 def __delfield_has_datebook(self): del self.__field_has_datebook
1632
1633 has_datebook=property(__getfield_has_datebook, __setfield_has_datebook, __delfield_has_datebook, None)
1634
1635 def __getfield_has_sms(self):
1636 return self.__field_has_sms.getvalue()
1637
1638 def __setfield_has_sms(self, value):
1639 if isinstance(value,CSVINT):
1640 self.__field_has_sms=value
1641 else:
1642 self.__field_has_sms=CSVINT(value,)
1643
1644 def __delfield_has_sms(self): del self.__field_has_sms
1645
1646 has_sms=property(__getfield_has_sms, __setfield_has_sms, __delfield_has_sms, None)
1647
1648 def __getfield_has_mo_sms(self):
1649 return self.__field_has_mo_sms.getvalue()
1650
1651 def __setfield_has_mo_sms(self, value):
1652 if isinstance(value,CSVINT):
1653 self.__field_has_mo_sms=value
1654 else:
1655 self.__field_has_mo_sms=CSVINT(value,)
1656
1657 def __delfield_has_mo_sms(self): del self.__field_has_mo_sms
1658
1659 has_mo_sms=property(__getfield_has_mo_sms, __setfield_has_mo_sms, __delfield_has_mo_sms, None)
1660
1661 def __getfield_has_email(self):
1662 return self.__field_has_email.getvalue()
1663
1664 def __setfield_has_email(self, value):
1665 if isinstance(value,CSVINT):
1666 self.__field_has_email=value
1667 else:
1668 self.__field_has_email=CSVINT(value,)
1669
1670 def __delfield_has_email(self): del self.__field_has_email
1671
1672 has_email=property(__getfield_has_email, __setfield_has_email, __delfield_has_email, None)
1673
1674 def __getfield_has_multi_phonebooks(self):
1675 return self.__field_has_multi_phonebooks.getvalue()
1676
1677 def __setfield_has_multi_phonebooks(self, value):
1678 if isinstance(value,CSVINT):
1679 self.__field_has_multi_phonebooks=value
1680 else:
1681 self.__field_has_multi_phonebooks=CSVINT(value,)
1682
1683 def __delfield_has_multi_phonebooks(self): del self.__field_has_multi_phonebooks
1684
1685 has_multi_phonebooks=property(__getfield_has_multi_phonebooks, __setfield_has_multi_phonebooks, __delfield_has_multi_phonebooks, None)
1686
1687 def __getfield_has_sim(self):
1688 return self.__field_has_sim.getvalue()
1689
1690 def __setfield_has_sim(self, value):
1691 if isinstance(value,CSVINT):
1692 self.__field_has_sim=value
1693 else:
1694 self.__field_has_sim=CSVINT(value,)
1695
1696 def __delfield_has_sim(self): del self.__field_has_sim
1697
1698 has_sim=property(__getfield_has_sim, __setfield_has_sim, __delfield_has_sim, None)
1699
1700 def __getfield_has_shared_phonebook(self):
1701 return self.__field_has_shared_phonebook.getvalue()
1702
1703 def __setfield_has_shared_phonebook(self, value):
1704 if isinstance(value,CSVINT):
1705 self.__field_has_shared_phonebook=value
1706 else:
1707 self.__field_has_shared_phonebook=CSVINT(value,)
1708
1709 def __delfield_has_shared_phonebook(self): del self.__field_has_shared_phonebook
1710
1711 has_shared_phonebook=property(__getfield_has_shared_phonebook, __setfield_has_shared_phonebook, __delfield_has_shared_phonebook, None)
1712
1713 def __getfield_has_multi_dest_addr(self):
1714 return self.__field_has_multi_dest_addr.getvalue()
1715
1716 def __setfield_has_multi_dest_addr(self, value):
1717 if isinstance(value,CSVINT):
1718 self.__field_has_multi_dest_addr=value
1719 else:
1720 self.__field_has_multi_dest_addr=CSVINT(value,)
1721
1722 def __delfield_has_multi_dest_addr(self): del self.__field_has_multi_dest_addr
1723
1724 has_multi_dest_addr=property(__getfield_has_multi_dest_addr, __setfield_has_multi_dest_addr, __delfield_has_multi_dest_addr, None)
1725
1726 def __getfield_has_ringtone_id(self):
1727 return self.__field_has_ringtone_id.getvalue()
1728
1729 def __setfield_has_ringtone_id(self, value):
1730 if isinstance(value,CSVINT):
1731 self.__field_has_ringtone_id=value
1732 else:
1733 self.__field_has_ringtone_id=CSVINT(value,)
1734
1735 def __delfield_has_ringtone_id(self): del self.__field_has_ringtone_id
1736
1737 has_ringtone_id=property(__getfield_has_ringtone_id, __setfield_has_ringtone_id, __delfield_has_ringtone_id, None)
1738
1739 def __getfield_has_voicetag(self):
1740 return self.__field_has_voicetag.getvalue()
1741
1742 def __setfield_has_voicetag(self, value):
1743 if isinstance(value,CSVINT):
1744 self.__field_has_voicetag=value
1745 else:
1746 self.__field_has_voicetag=CSVINT(value,)
1747
1748 def __delfield_has_voicetag(self): del self.__field_has_voicetag
1749
1750 has_voicetag=property(__getfield_has_voicetag, __setfield_has_voicetag, __delfield_has_voicetag, None)
1751
1752 def __getfield_dunno(self):
1753 try: self.__field_dunno
1754 except:
1755 self.__field_dunno=CSVSTRING(**{ 'quotechar': None, 'terminator': None })
1756 return self.__field_dunno.getvalue()
1757
1758 def __setfield_dunno(self, value):
1759 if isinstance(value,CSVSTRING):
1760 self.__field_dunno=value
1761 else:
1762 self.__field_dunno=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None })
1763
1764 def __delfield_dunno(self): del self.__field_dunno
1765
1766 dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, None)
1767
1768 def iscontainer(self):
1769 return True
1770
1771 def containerelements(self):
1772 yield ('command', self.__field_command, None)
1773 yield ('has_phonebook', self.__field_has_phonebook, None)
1774 yield ('has_datebook', self.__field_has_datebook, None)
1775 yield ('has_sms', self.__field_has_sms, None)
1776 yield ('has_mo_sms', self.__field_has_mo_sms, None)
1777 yield ('has_email', self.__field_has_email, None)
1778 yield ('has_multi_phonebooks', self.__field_has_multi_phonebooks, None)
1779 yield ('has_sim', self.__field_has_sim, None)
1780 yield ('has_shared_phonebook', self.__field_has_shared_phonebook, None)
1781 yield ('has_multi_dest_addr', self.__field_has_multi_dest_addr, None)
1782 yield ('has_ringtone_id', self.__field_has_ringtone_id, None)
1783 yield ('has_voicetag', self.__field_has_voicetag, None)
1784 yield ('dunno', self.__field_dunno, None)
1785
1786
1787
1788
1789 class select_phonebook_req(BaseProtogenClass):
1790 __fields=['command', 'pb_type']
1791
1792 def __init__(self, *args, **kwargs):
1793 dict={}
1794 dict.update(kwargs)
1796 super(select_phonebook_req,self).__init__(**dict)
1798 if self.__class__ is select_phonebook_req:
1799 self._update(args,dict)
1800
1801
1802 def getfields(self):
1803 return self.__fields
1804
1805
1806 def _update(self, args, kwargs):
1807 super(select_phonebook_req,self)._update(args,kwargs)
1808 keys=kwargs.keys()
1809 for key in keys:
1810 if key in self.__fields:
1811 setattr(self, key, kwargs[key])
1812 del kwargs[key]
1813 if __debug__:
1815 self._complainaboutunusedargs(select_phonebook_req,kwargs)
1816 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1817
1819
1820 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1821 'Writes this packet to the supplied buffer'
1822 self._bufferstartoffset=buf.getcurrentoffset()
1823 try: self.__field_command
1824 except:
1825 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+CPBS=' })
1826 self.__field_command.writetobuffer(buf)
1827 try: self.__field_pb_type
1828 except:
1829 self.__field_pb_type=CSVSTRING(**{ 'terminator': None, 'default': PB_MAIN })
1830 self.__field_pb_type.writetobuffer(buf)
1831 self._bufferendoffset=buf.getcurrentoffset()
1832 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1833
1834
1835 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1836 'Reads this packet from the supplied buffer'
1837 self._bufferstartoffset=buf.getcurrentoffset()
1838 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1839 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+CPBS=' })
1840 self.__field_command.readfrombuffer(buf)
1841 self.__field_pb_type=CSVSTRING(**{ 'terminator': None, 'default': PB_MAIN })
1842 self.__field_pb_type.readfrombuffer(buf)
1843 self._bufferendoffset=buf.getcurrentoffset()
1844
1845
1846 def __getfield_command(self):
1847 try: self.__field_command
1848 except:
1849 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+CPBS=' })
1850 return self.__field_command.getvalue()
1851
1852 def __setfield_command(self, value):
1853 if isinstance(value,CSVSTRING):
1854 self.__field_command=value
1855 else:
1856 self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None, 'default': '+CPBS=' })
1857
1858 def __delfield_command(self): del self.__field_command
1859
1860 command=property(__getfield_command, __setfield_command, __delfield_command, None)
1861
1862 def __getfield_pb_type(self):
1863 try: self.__field_pb_type
1864 except:
1865 self.__field_pb_type=CSVSTRING(**{ 'terminator': None, 'default': PB_MAIN })
1866 return self.__field_pb_type.getvalue()
1867
1868 def __setfield_pb_type(self, value):
1869 if isinstance(value,CSVSTRING):
1870 self.__field_pb_type=value
1871 else:
1872 self.__field_pb_type=CSVSTRING(value,**{ 'terminator': None, 'default': PB_MAIN })
1873
1874 def __delfield_pb_type(self): del self.__field_pb_type
1875
1876 pb_type=property(__getfield_pb_type, __setfield_pb_type, __delfield_pb_type, None)
1877
1878 def iscontainer(self):
1879 return True
1880
1881 def containerelements(self):
1882 yield ('command', self.__field_command, None)
1883 yield ('pb_type', self.__field_pb_type, None)
1884
1885
1886
1887
1888 class read_pb_simple_req(BaseProtogenClass):
1889 __fields=['command', 'start_index', 'end_index']
1890
1891 def __init__(self, *args, **kwargs):
1892 dict={}
1893 dict.update(kwargs)
1895 super(read_pb_simple_req,self).__init__(**dict)
1897 if self.__class__ is read_pb_simple_req:
1898 self._update(args,dict)
1899
1900
1901 def getfields(self):
1902 return self.__fields
1903
1904
1905 def _update(self, args, kwargs):
1906 super(read_pb_simple_req,self)._update(args,kwargs)
1907 keys=kwargs.keys()
1908 for key in keys:
1909 if key in self.__fields:
1910 setattr(self, key, kwargs[key])
1911 del kwargs[key]
1912 if __debug__:
1914 self._complainaboutunusedargs(read_pb_simple_req,kwargs)
1915 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1916
1918
1919 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1920 'Writes this packet to the supplied buffer'
1921 self._bufferstartoffset=buf.getcurrentoffset()
1922 try: self.__field_command
1923 except:
1924 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+CPBR=' })
1925 self.__field_command.writetobuffer(buf)
1926 try: self.__field_start_index
1927 except:
1928 self.__field_start_index=CSVINT(**{ 'default': 1 })
1929 self.__field_start_index.writetobuffer(buf)
1930 try: self.__field_end_index
1931 except:
1932 self.__field_end_index=CSVINT(**{ 'terminator': None, 'default': self.start_index })
1933 self.__field_end_index.writetobuffer(buf)
1934 self._bufferendoffset=buf.getcurrentoffset()
1935 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1936
1937
1938 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1939 'Reads this packet from the supplied buffer'
1940 self._bufferstartoffset=buf.getcurrentoffset()
1941 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1942 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+CPBR=' })
1943 self.__field_command.readfrombuffer(buf)
1944 self.__field_start_index=CSVINT(**{ 'default': 1 })
1945 self.__field_start_index.readfrombuffer(buf)
1946 self.__field_end_index=CSVINT(**{ 'terminator': None, 'default': self.start_index })
1947 self.__field_end_index.readfrombuffer(buf)
1948 self._bufferendoffset=buf.getcurrentoffset()
1949
1950
1951 def __getfield_command(self):
1952 try: self.__field_command
1953 except:
1954 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+CPBR=' })
1955 return self.__field_command.getvalue()
1956
1957 def __setfield_command(self, value):
1958 if isinstance(value,CSVSTRING):
1959 self.__field_command=value
1960 else:
1961 self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None, 'default': '+CPBR=' })
1962
1963 def __delfield_command(self): del self.__field_command
1964
1965 command=property(__getfield_command, __setfield_command, __delfield_command, None)
1966
1967 def __getfield_start_index(self):
1968 try: self.__field_start_index
1969 except:
1970 self.__field_start_index=CSVINT(**{ 'default': 1 })
1971 return self.__field_start_index.getvalue()
1972
1973 def __setfield_start_index(self, value):
1974 if isinstance(value,CSVINT):
1975 self.__field_start_index=value
1976 else:
1977 self.__field_start_index=CSVINT(value,**{ 'default': 1 })
1978
1979 def __delfield_start_index(self): del self.__field_start_index
1980
1981 start_index=property(__getfield_start_index, __setfield_start_index, __delfield_start_index, None)
1982
1983 def __getfield_end_index(self):
1984 try: self.__field_end_index
1985 except:
1986 self.__field_end_index=CSVINT(**{ 'terminator': None, 'default': self.start_index })
1987 return self.__field_end_index.getvalue()
1988
1989 def __setfield_end_index(self, value):
1990 if isinstance(value,CSVINT):
1991 self.__field_end_index=value
1992 else:
1993 self.__field_end_index=CSVINT(value,**{ 'terminator': None, 'default': self.start_index })
1994
1995 def __delfield_end_index(self): del self.__field_end_index
1996
1997 end_index=property(__getfield_end_index, __setfield_end_index, __delfield_end_index, None)
1998
1999 def iscontainer(self):
2000 return True
2001
2002 def containerelements(self):
2003 yield ('command', self.__field_command, None)
2004 yield ('start_index', self.__field_start_index, None)
2005 yield ('end_index', self.__field_end_index, None)
2006
2007
2008
2009
2010 class read_pb_simple_resp(BaseProtogenClass):
2011 __fields=['command', 'index', 'number', 'local_type', 'name']
2012
2013 def __init__(self, *args, **kwargs):
2014 dict={}
2015 dict.update(kwargs)
2017 super(read_pb_simple_resp,self).__init__(**dict)
2019 if self.__class__ is read_pb_simple_resp:
2020 self._update(args,dict)
2021
2022
2023 def getfields(self):
2024 return self.__fields
2025
2026
2027 def _update(self, args, kwargs):
2028 super(read_pb_simple_resp,self)._update(args,kwargs)
2029 keys=kwargs.keys()
2030 for key in keys:
2031 if key in self.__fields:
2032 setattr(self, key, kwargs[key])
2033 del kwargs[key]
2034 if __debug__:
2036 self._complainaboutunusedargs(read_pb_simple_resp,kwargs)
2037 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2038
2040
2041 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2042 'Writes this packet to the supplied buffer'
2043 self._bufferstartoffset=buf.getcurrentoffset()
2044 try: self.__field_command
2045 except:
2046 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': ord(' '), 'default': '+CPBR:' })
2047 self.__field_command.writetobuffer(buf)
2048 self.__field_index.writetobuffer(buf)
2049 self.__field_number.writetobuffer(buf)
2050 self.__field_local_type.writetobuffer(buf)
2051 self.__field_name.writetobuffer(buf)
2052 self._bufferendoffset=buf.getcurrentoffset()
2053 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2054
2055
2056 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2057 'Reads this packet from the supplied buffer'
2058 self._bufferstartoffset=buf.getcurrentoffset()
2059 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2060 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': ord(' '), 'default': '+CPBR:' })
2061 self.__field_command.readfrombuffer(buf)
2062 self.__field_index=CSVINT()
2063 self.__field_index.readfrombuffer(buf)
2064 self.__field_number=CSVSTRING()
2065 self.__field_number.readfrombuffer(buf)
2066 self.__field_local_type=CSVINT()
2067 self.__field_local_type.readfrombuffer(buf)
2068 self.__field_name=CSVSTRING(**{ 'terminator': None })
2069 self.__field_name.readfrombuffer(buf)
2070 self._bufferendoffset=buf.getcurrentoffset()
2071
2072
2073 def __getfield_command(self):
2074 try: self.__field_command
2075 except:
2076 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': ord(' '), 'default': '+CPBR:' })
2077 return self.__field_command.getvalue()
2078
2079 def __setfield_command(self, value):
2080 if isinstance(value,CSVSTRING):
2081 self.__field_command=value
2082 else:
2083 self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': ord(' '), 'default': '+CPBR:' })
2084
2085 def __delfield_command(self): del self.__field_command
2086
2087 command=property(__getfield_command, __setfield_command, __delfield_command, None)
2088
2089 def __getfield_index(self):
2090 return self.__field_index.getvalue()
2091
2092 def __setfield_index(self, value):
2093 if isinstance(value,CSVINT):
2094 self.__field_index=value
2095 else:
2096 self.__field_index=CSVINT(value,)
2097
2098 def __delfield_index(self): del self.__field_index
2099
2100 index=property(__getfield_index, __setfield_index, __delfield_index, None)
2101
2102 def __getfield_number(self):
2103 return self.__field_number.getvalue()
2104
2105 def __setfield_number(self, value):
2106 if isinstance(value,CSVSTRING):
2107 self.__field_number=value
2108 else:
2109 self.__field_number=CSVSTRING(value,)
2110
2111 def __delfield_number(self): del self.__field_number
2112
2113 number=property(__getfield_number, __setfield_number, __delfield_number, None)
2114
2115 def __getfield_local_type(self):
2116 return self.__field_local_type.getvalue()
2117
2118 def __setfield_local_type(self, value):
2119 if isinstance(value,CSVINT):
2120 self.__field_local_type=value
2121 else:
2122 self.__field_local_type=CSVINT(value,)
2123
2124 def __delfield_local_type(self): del self.__field_local_type
2125
2126 local_type=property(__getfield_local_type, __setfield_local_type, __delfield_local_type, None)
2127
2128 def __getfield_name(self):
2129 return self.__field_name.getvalue()
2130
2131 def __setfield_name(self, value):
2132 if isinstance(value,CSVSTRING):
2133 self.__field_name=value
2134 else:
2135 self.__field_name=CSVSTRING(value,**{ 'terminator': None })
2136
2137 def __delfield_name(self): del self.__field_name
2138
2139 name=property(__getfield_name, __setfield_name, __delfield_name, None)
2140
2141 def iscontainer(self):
2142 return True
2143
2144 def containerelements(self):
2145 yield ('command', self.__field_command, None)
2146 yield ('index', self.__field_index, None)
2147 yield ('number', self.__field_number, None)
2148 yield ('local_type', self.__field_local_type, None)
2149 yield ('name', self.__field_name, None)
2150
2151
2152
2153
2154 class read_pb_req(BaseProtogenClass):
2155 __fields=['command', 'start_index', 'end_index']
2156
2157 def __init__(self, *args, **kwargs):
2158 dict={}
2159 dict.update(kwargs)
2161 super(read_pb_req,self).__init__(**dict)
2163 if self.__class__ is read_pb_req:
2164 self._update(args,dict)
2165
2166
2167 def getfields(self):
2168 return self.__fields
2169
2170
2171 def _update(self, args, kwargs):
2172 super(read_pb_req,self)._update(args,kwargs)
2173 keys=kwargs.keys()
2174 for key in keys:
2175 if key in self.__fields:
2176 setattr(self, key, kwargs[key])
2177 del kwargs[key]
2178 if __debug__:
2180 self._complainaboutunusedargs(read_pb_req,kwargs)
2181 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2182
2184
2185 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2186 'Writes this packet to the supplied buffer'
2187 self._bufferstartoffset=buf.getcurrentoffset()
2188 try: self.__field_command
2189 except:
2190 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+MPBR=' })
2191 self.__field_command.writetobuffer(buf)
2192 try: self.__field_start_index
2193 except:
2194 self.__field_start_index=CSVINT(**{ 'default': 1 })
2195 self.__field_start_index.writetobuffer(buf)
2196 try: self.__field_end_index
2197 except:
2198 self.__field_end_index=CSVINT(**{ 'terminator': None, 'default': self.start_index })
2199 self.__field_end_index.writetobuffer(buf)
2200 self._bufferendoffset=buf.getcurrentoffset()
2201 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2202
2203
2204 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2205 'Reads this packet from the supplied buffer'
2206 self._bufferstartoffset=buf.getcurrentoffset()
2207 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2208 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+MPBR=' })
2209 self.__field_command.readfrombuffer(buf)
2210 self.__field_start_index=CSVINT(**{ 'default': 1 })
2211 self.__field_start_index.readfrombuffer(buf)
2212 self.__field_end_index=CSVINT(**{ 'terminator': None, 'default': self.start_index })
2213 self.__field_end_index.readfrombuffer(buf)
2214 self._bufferendoffset=buf.getcurrentoffset()
2215
2216
2217 def __getfield_command(self):
2218 try: self.__field_command
2219 except:
2220 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+MPBR=' })
2221 return self.__field_command.getvalue()
2222
2223 def __setfield_command(self, value):
2224 if isinstance(value,CSVSTRING):
2225 self.__field_command=value
2226 else:
2227 self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None, 'default': '+MPBR=' })
2228
2229 def __delfield_command(self): del self.__field_command
2230
2231 command=property(__getfield_command, __setfield_command, __delfield_command, None)
2232
2233 def __getfield_start_index(self):
2234 try: self.__field_start_index
2235 except:
2236 self.__field_start_index=CSVINT(**{ 'default': 1 })
2237 return self.__field_start_index.getvalue()
2238
2239 def __setfield_start_index(self, value):
2240 if isinstance(value,CSVINT):
2241 self.__field_start_index=value
2242 else:
2243 self.__field_start_index=CSVINT(value,**{ 'default': 1 })
2244
2245 def __delfield_start_index(self): del self.__field_start_index
2246
2247 start_index=property(__getfield_start_index, __setfield_start_index, __delfield_start_index, None)
2248
2249 def __getfield_end_index(self):
2250 try: self.__field_end_index
2251 except:
2252 self.__field_end_index=CSVINT(**{ 'terminator': None, 'default': self.start_index })
2253 return self.__field_end_index.getvalue()
2254
2255 def __setfield_end_index(self, value):
2256 if isinstance(value,CSVINT):
2257 self.__field_end_index=value
2258 else:
2259 self.__field_end_index=CSVINT(value,**{ 'terminator': None, 'default': self.start_index })
2260
2261 def __delfield_end_index(self): del self.__field_end_index
2262
2263 end_index=property(__getfield_end_index, __setfield_end_index, __delfield_end_index, None)
2264
2265 def iscontainer(self):
2266 return True
2267
2268 def containerelements(self):
2269 yield ('command', self.__field_command, None)
2270 yield ('start_index', self.__field_start_index, None)
2271 yield ('end_index', self.__field_end_index, None)
2272
2273
2274
2275
2276 class read_pb_resp(BaseProtogenClass):
2277 __fields=['command', 'index', 'number', 'local_type', 'name', 'number_type', 'voice_tag', 'ringtone', 'backlight', 'is_primary', 'group', 'icon', 'first_last_enabled', 'subfield_index', 'picture_name', 'dunno']
2278
2279 def __init__(self, *args, **kwargs):
2280 dict={}
2281 dict.update(kwargs)
2283 super(read_pb_resp,self).__init__(**dict)
2285 if self.__class__ is read_pb_resp:
2286 self._update(args,dict)
2287
2288
2289 def getfields(self):
2290 return self.__fields
2291
2292
2293 def _update(self, args, kwargs):
2294 super(read_pb_resp,self)._update(args,kwargs)
2295 keys=kwargs.keys()
2296 for key in keys:
2297 if key in self.__fields:
2298 setattr(self, key, kwargs[key])
2299 del kwargs[key]
2300 if __debug__:
2302 self._complainaboutunusedargs(read_pb_resp,kwargs)
2303 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2304
2306
2307 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2308 'Writes this packet to the supplied buffer'
2309 self._bufferstartoffset=buf.getcurrentoffset()
2310 self.__field_command.writetobuffer(buf)
2311 self.__field_index.writetobuffer(buf)
2312 self.__field_number.writetobuffer(buf)
2313 self.__field_local_type.writetobuffer(buf)
2314 self.__field_name.writetobuffer(buf)
2315 self.__field_number_type.writetobuffer(buf)
2316 self.__field_voice_tag.writetobuffer(buf)
2317 self.__field_ringtone.writetobuffer(buf)
2318 self.__field_backlight.writetobuffer(buf)
2319 self.__field_is_primary.writetobuffer(buf)
2320 self.__field_group.writetobuffer(buf)
2321 self.__field_icon.writetobuffer(buf)
2322 self.__field_first_last_enabled.writetobuffer(buf)
2323 self.__field_subfield_index.writetobuffer(buf)
2324 self.__field_picture_name.writetobuffer(buf)
2325 self.__field_dunno.writetobuffer(buf)
2326 self._bufferendoffset=buf.getcurrentoffset()
2327 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2328
2329
2330 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2331 'Reads this packet from the supplied buffer'
2332 self._bufferstartoffset=buf.getcurrentoffset()
2333 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2334 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': ord(' '), 'default': '+MPBR:' })
2335 self.__field_command.readfrombuffer(buf)
2336 self.__field_index=CSVINT()
2337 self.__field_index.readfrombuffer(buf)
2338 self.__field_number=CSVSTRING()
2339 self.__field_number.readfrombuffer(buf)
2340 self.__field_local_type=CSVINT()
2341 self.__field_local_type.readfrombuffer(buf)
2342 self.__field_name=CSVSTRING()
2343 self.__field_name.readfrombuffer(buf)
2344 self.__field_number_type=CSVINT()
2345 self.__field_number_type.readfrombuffer(buf)
2346 self.__field_voice_tag=CSVINT()
2347 self.__field_voice_tag.readfrombuffer(buf)
2348 self.__field_ringtone=CSVINT()
2349 self.__field_ringtone.readfrombuffer(buf)
2350 self.__field_backlight=CSVINT()
2351 self.__field_backlight.readfrombuffer(buf)
2352 self.__field_is_primary=CSVINT()
2353 self.__field_is_primary.readfrombuffer(buf)
2354 self.__field_group=CSVINT()
2355 self.__field_group.readfrombuffer(buf)
2356 self.__field_icon=CSVINT()
2357 self.__field_icon.readfrombuffer(buf)
2358 self.__field_first_last_enabled=CSVINT()
2359 self.__field_first_last_enabled.readfrombuffer(buf)
2360 self.__field_subfield_index=CSVINT()
2361 self.__field_subfield_index.readfrombuffer(buf)
2362 self.__field_picture_name=CSVSTRING()
2363 self.__field_picture_name.readfrombuffer(buf)
2364 self.__field_dunno=CSVSTRING(**{ 'quotechar': None, 'terminator': None })
2365 self.__field_dunno.readfrombuffer(buf)
2366 self._bufferendoffset=buf.getcurrentoffset()
2367
2368
2369 def __getfield_command(self):
2370 return self.__field_command.getvalue()
2371
2372 def __setfield_command(self, value):
2373 if isinstance(value,CSVSTRING):
2374 self.__field_command=value
2375 else:
2376 self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': ord(' '), 'default': '+MPBR:' })
2377
2378 def __delfield_command(self): del self.__field_command
2379
2380 command=property(__getfield_command, __setfield_command, __delfield_command, None)
2381
2382 def __getfield_index(self):
2383 return self.__field_index.getvalue()
2384
2385 def __setfield_index(self, value):
2386 if isinstance(value,CSVINT):
2387 self.__field_index=value
2388 else:
2389 self.__field_index=CSVINT(value,)
2390
2391 def __delfield_index(self): del self.__field_index
2392
2393 index=property(__getfield_index, __setfield_index, __delfield_index, None)
2394
2395 def __getfield_number(self):
2396 return self.__field_number.getvalue()
2397
2398 def __setfield_number(self, value):
2399 if isinstance(value,CSVSTRING):
2400 self.__field_number=value
2401 else:
2402 self.__field_number=CSVSTRING(value,)
2403
2404 def __delfield_number(self): del self.__field_number
2405
2406 number=property(__getfield_number, __setfield_number, __delfield_number, None)
2407
2408 def __getfield_local_type(self):
2409 return self.__field_local_type.getvalue()
2410
2411 def __setfield_local_type(self, value):
2412 if isinstance(value,CSVINT):
2413 self.__field_local_type=value
2414 else:
2415 self.__field_local_type=CSVINT(value,)
2416
2417 def __delfield_local_type(self): del self.__field_local_type
2418
2419 local_type=property(__getfield_local_type, __setfield_local_type, __delfield_local_type, None)
2420
2421 def __getfield_name(self):
2422 return self.__field_name.getvalue()
2423
2424 def __setfield_name(self, value):
2425 if isinstance(value,CSVSTRING):
2426 self.__field_name=value
2427 else:
2428 self.__field_name=CSVSTRING(value,)
2429
2430 def __delfield_name(self): del self.__field_name
2431
2432 name=property(__getfield_name, __setfield_name, __delfield_name, None)
2433
2434 def __getfield_number_type(self):
2435 return self.__field_number_type.getvalue()
2436
2437 def __setfield_number_type(self, value):
2438 if isinstance(value,CSVINT):
2439 self.__field_number_type=value
2440 else:
2441 self.__field_number_type=CSVINT(value,)
2442
2443 def __delfield_number_type(self): del self.__field_number_type
2444
2445 number_type=property(__getfield_number_type, __setfield_number_type, __delfield_number_type, None)
2446
2447 def __getfield_voice_tag(self):
2448 return self.__field_voice_tag.getvalue()
2449
2450 def __setfield_voice_tag(self, value):
2451 if isinstance(value,CSVINT):
2452 self.__field_voice_tag=value
2453 else:
2454 self.__field_voice_tag=CSVINT(value,)
2455
2456 def __delfield_voice_tag(self): del self.__field_voice_tag
2457
2458 voice_tag=property(__getfield_voice_tag, __setfield_voice_tag, __delfield_voice_tag, None)
2459
2460 def __getfield_ringtone(self):
2461 return self.__field_ringtone.getvalue()
2462
2463 def __setfield_ringtone(self, value):
2464 if isinstance(value,CSVINT):
2465 self.__field_ringtone=value
2466 else:
2467 self.__field_ringtone=CSVINT(value,)
2468
2469 def __delfield_ringtone(self): del self.__field_ringtone
2470
2471 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None)
2472
2473 def __getfield_backlight(self):
2474 return self.__field_backlight.getvalue()
2475
2476 def __setfield_backlight(self, value):
2477 if isinstance(value,CSVINT):
2478 self.__field_backlight=value
2479 else:
2480 self.__field_backlight=CSVINT(value,)
2481
2482 def __delfield_backlight(self): del self.__field_backlight
2483
2484 backlight=property(__getfield_backlight, __setfield_backlight, __delfield_backlight, None)
2485
2486 def __getfield_is_primary(self):
2487 return self.__field_is_primary.getvalue()
2488
2489 def __setfield_is_primary(self, value):
2490 if isinstance(value,CSVINT):
2491 self.__field_is_primary=value
2492 else:
2493 self.__field_is_primary=CSVINT(value,)
2494
2495 def __delfield_is_primary(self): del self.__field_is_primary
2496
2497 is_primary=property(__getfield_is_primary, __setfield_is_primary, __delfield_is_primary, None)
2498
2499 def __getfield_group(self):
2500 return self.__field_group.getvalue()
2501
2502 def __setfield_group(self, value):
2503 if isinstance(value,CSVINT):
2504 self.__field_group=value
2505 else:
2506 self.__field_group=CSVINT(value,)
2507
2508 def __delfield_group(self): del self.__field_group
2509
2510 group=property(__getfield_group, __setfield_group, __delfield_group, None)
2511
2512 def __getfield_icon(self):
2513 return self.__field_icon.getvalue()
2514
2515 def __setfield_icon(self, value):
2516 if isinstance(value,CSVINT):
2517 self.__field_icon=value
2518 else:
2519 self.__field_icon=CSVINT(value,)
2520
2521 def __delfield_icon(self): del self.__field_icon
2522
2523 icon=property(__getfield_icon, __setfield_icon, __delfield_icon, None)
2524
2525 def __getfield_first_last_enabled(self):
2526 return self.__field_first_last_enabled.getvalue()
2527
2528 def __setfield_first_last_enabled(self, value):
2529 if isinstance(value,CSVINT):
2530 self.__field_first_last_enabled=value
2531 else:
2532 self.__field_first_last_enabled=CSVINT(value,)
2533
2534 def __delfield_first_last_enabled(self): del self.__field_first_last_enabled
2535
2536 first_last_enabled=property(__getfield_first_last_enabled, __setfield_first_last_enabled, __delfield_first_last_enabled, None)
2537
2538 def __getfield_subfield_index(self):
2539 return self.__field_subfield_index.getvalue()
2540
2541 def __setfield_subfield_index(self, value):
2542 if isinstance(value,CSVINT):
2543 self.__field_subfield_index=value
2544 else:
2545 self.__field_subfield_index=CSVINT(value,)
2546
2547 def __delfield_subfield_index(self): del self.__field_subfield_index
2548
2549 subfield_index=property(__getfield_subfield_index, __setfield_subfield_index, __delfield_subfield_index, None)
2550
2551 def __getfield_picture_name(self):
2552 return self.__field_picture_name.getvalue()
2553
2554 def __setfield_picture_name(self, value):
2555 if isinstance(value,CSVSTRING):
2556 self.__field_picture_name=value
2557 else:
2558 self.__field_picture_name=CSVSTRING(value,)
2559
2560 def __delfield_picture_name(self): del self.__field_picture_name
2561
2562 picture_name=property(__getfield_picture_name, __setfield_picture_name, __delfield_picture_name, None)
2563
2564 def __getfield_dunno(self):
2565 return self.__field_dunno.getvalue()
2566
2567 def __setfield_dunno(self, value):
2568 if isinstance(value,CSVSTRING):
2569 self.__field_dunno=value
2570 else:
2571 self.__field_dunno=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None })
2572
2573 def __delfield_dunno(self): del self.__field_dunno
2574
2575 dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, None)
2576
2577 def iscontainer(self):
2578 return True
2579
2580 def containerelements(self):
2581 yield ('command', self.__field_command, None)
2582 yield ('index', self.__field_index, None)
2583 yield ('number', self.__field_number, None)
2584 yield ('local_type', self.__field_local_type, None)
2585 yield ('name', self.__field_name, None)
2586 yield ('number_type', self.__field_number_type, None)
2587 yield ('voice_tag', self.__field_voice_tag, None)
2588 yield ('ringtone', self.__field_ringtone, None)
2589 yield ('backlight', self.__field_backlight, None)
2590 yield ('is_primary', self.__field_is_primary, None)
2591 yield ('group', self.__field_group, None)
2592 yield ('icon', self.__field_icon, None)
2593 yield ('first_last_enabled', self.__field_first_last_enabled, None)
2594 yield ('subfield_index', self.__field_subfield_index, None)
2595 yield ('picture_name', self.__field_picture_name, None)
2596 yield ('dunno', self.__field_dunno, None)
2597
2598
2599
2600
2601 class write_pb_req(BaseProtogenClass):
2602 __fields=['command', 'index', 'number', 'local_type', 'name', 'number_type', 'voice_tag', 'ringtone', 'backlight', 'is_primary', 'group', 'icon', 'first_last_enabled', 'subfield_index', 'picture_name']
2603
2604 def __init__(self, *args, **kwargs):
2605 dict={}
2606 dict.update(kwargs)
2608 super(write_pb_req,self).__init__(**dict)
2610 if self.__class__ is write_pb_req:
2611 self._update(args,dict)
2612
2613
2614 def getfields(self):
2615 return self.__fields
2616
2617
2618 def _update(self, args, kwargs):
2619 super(write_pb_req,self)._update(args,kwargs)
2620 keys=kwargs.keys()
2621 for key in keys:
2622 if key in self.__fields:
2623 setattr(self, key, kwargs[key])
2624 del kwargs[key]
2625 if __debug__:
2627 self._complainaboutunusedargs(write_pb_req,kwargs)
2628 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2629
2631
2632 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2633 'Writes this packet to the supplied buffer'
2634 self._bufferstartoffset=buf.getcurrentoffset()
2635 try: self.__field_command
2636 except:
2637 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+MPBW=' })
2638 self.__field_command.writetobuffer(buf)
2639 self.__field_index.writetobuffer(buf)
2640 self.__field_number.writetobuffer(buf)
2641 try: self.__field_local_type
2642 except:
2643 self.__field_local_type=CSVINT(**{ 'default': LOCAL_TYPE_LOCAL })
2644 self.__field_local_type.writetobuffer(buf)
2645 self.__field_name.writetobuffer(buf)
2646 self.__field_number_type.writetobuffer(buf)
2647 try: self.__field_voice_tag
2648 except:
2649 self.__field_voice_tag=CSVINT(**{ 'default': 0 })
2650 self.__field_voice_tag.writetobuffer(buf)
2651 try: self.__field_ringtone
2652 except:
2653 self.__field_ringtone=CSVINT(**{ 'default': 255 })
2654 self.__field_ringtone.writetobuffer(buf)
2655 try: self.__field_backlight
2656 except:
2657 self.__field_backlight=CSVINT(**{ 'default': 0 })
2658 self.__field_backlight.writetobuffer(buf)
2659 try: self.__field_is_primary
2660 except:
2661 self.__field_is_primary=CSVINT(**{ 'default': 0 })
2662 self.__field_is_primary.writetobuffer(buf)
2663 try: self.__field_group
2664 except:
2665 self.__field_group=CSVINT(**{ 'default': 1 })
2666 self.__field_group.writetobuffer(buf)
2667 try: self.__field_icon
2668 except:
2669 self.__field_icon=CSVINT(**{ 'default': 255 })
2670 self.__field_icon.writetobuffer(buf)
2671 try: self.__field_first_last_enabled
2672 except:
2673 self.__field_first_last_enabled=CSVINT(**{ 'default': 255 })
2674 self.__field_first_last_enabled.writetobuffer(buf)
2675 try: self.__field_subfield_index
2676 except:
2677 self.__field_subfield_index=CSVINT(**{ 'default': 0 })
2678 self.__field_subfield_index.writetobuffer(buf)
2679 try: self.__field_picture_name
2680 except:
2681 self.__field_picture_name=CSVSTRING(**{ 'terminator': None, 'default': "" })
2682 self.__field_picture_name.writetobuffer(buf)
2683 self._bufferendoffset=buf.getcurrentoffset()
2684 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2685
2686
2687 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2688 'Reads this packet from the supplied buffer'
2689 self._bufferstartoffset=buf.getcurrentoffset()
2690 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2691 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+MPBW=' })
2692 self.__field_command.readfrombuffer(buf)
2693 self.__field_index=CSVINT()
2694 self.__field_index.readfrombuffer(buf)
2695 self.__field_number=CSVSTRING(**{ 'maxsizeinbytes': PB_MAX_NUMBER_LEN, 'raiseontruncate': False })
2696 self.__field_number.readfrombuffer(buf)
2697 self.__field_local_type=CSVINT(**{ 'default': LOCAL_TYPE_LOCAL })
2698 self.__field_local_type.readfrombuffer(buf)
2699 self.__field_name=CSVSTRING(**{ 'maxsizeinbytes': PB_MAX_NAME_LEN, 'raiseontruncate': False })
2700 self.__field_name.readfrombuffer(buf)
2701 self.__field_number_type=CSVINT()
2702 self.__field_number_type.readfrombuffer(buf)
2703 self.__field_voice_tag=CSVINT(**{ 'default': 0 })
2704 self.__field_voice_tag.readfrombuffer(buf)
2705 self.__field_ringtone=CSVINT(**{ 'default': 255 })
2706 self.__field_ringtone.readfrombuffer(buf)
2707 self.__field_backlight=CSVINT(**{ 'default': 0 })
2708 self.__field_backlight.readfrombuffer(buf)
2709 self.__field_is_primary=CSVINT(**{ 'default': 0 })
2710 self.__field_is_primary.readfrombuffer(buf)
2711 self.__field_group=CSVINT(**{ 'default': 1 })
2712 self.__field_group.readfrombuffer(buf)
2713 self.__field_icon=CSVINT(**{ 'default': 255 })
2714 self.__field_icon.readfrombuffer(buf)
2715 self.__field_first_last_enabled=CSVINT(**{ 'default': 255 })
2716 self.__field_first_last_enabled.readfrombuffer(buf)
2717 self.__field_subfield_index=CSVINT(**{ 'default': 0 })
2718 self.__field_subfield_index.readfrombuffer(buf)
2719 self.__field_picture_name=CSVSTRING(**{ 'terminator': None, 'default': "" })
2720 self.__field_picture_name.readfrombuffer(buf)
2721 self._bufferendoffset=buf.getcurrentoffset()
2722
2723
2724 def __getfield_command(self):
2725 try: self.__field_command
2726 except:
2727 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+MPBW=' })
2728 return self.__field_command.getvalue()
2729
2730 def __setfield_command(self, value):
2731 if isinstance(value,CSVSTRING):
2732 self.__field_command=value
2733 else:
2734 self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None, 'default': '+MPBW=' })
2735
2736 def __delfield_command(self): del self.__field_command
2737
2738 command=property(__getfield_command, __setfield_command, __delfield_command, None)
2739
2740 def __getfield_index(self):
2741 return self.__field_index.getvalue()
2742
2743 def __setfield_index(self, value):
2744 if isinstance(value,CSVINT):
2745 self.__field_index=value
2746 else:
2747 self.__field_index=CSVINT(value,)
2748
2749 def __delfield_index(self): del self.__field_index
2750
2751 index=property(__getfield_index, __setfield_index, __delfield_index, None)
2752
2753 def __getfield_number(self):
2754 return self.__field_number.getvalue()
2755
2756 def __setfield_number(self, value):
2757 if isinstance(value,CSVSTRING):
2758 self.__field_number=value
2759 else:
2760 self.__field_number=CSVSTRING(value,**{ 'maxsizeinbytes': PB_MAX_NUMBER_LEN, 'raiseontruncate': False })
2761
2762 def __delfield_number(self): del self.__field_number
2763
2764 number=property(__getfield_number, __setfield_number, __delfield_number, None)
2765
2766 def __getfield_local_type(self):
2767 try: self.__field_local_type
2768 except:
2769 self.__field_local_type=CSVINT(**{ 'default': LOCAL_TYPE_LOCAL })
2770 return self.__field_local_type.getvalue()
2771
2772 def __setfield_local_type(self, value):
2773 if isinstance(value,CSVINT):
2774 self.__field_local_type=value
2775 else:
2776 self.__field_local_type=CSVINT(value,**{ 'default': LOCAL_TYPE_LOCAL })
2777
2778 def __delfield_local_type(self): del self.__field_local_type
2779
2780 local_type=property(__getfield_local_type, __setfield_local_type, __delfield_local_type, None)
2781
2782 def __getfield_name(self):
2783 return self.__field_name.getvalue()
2784
2785 def __setfield_name(self, value):
2786 if isinstance(value,CSVSTRING):
2787 self.__field_name=value
2788 else:
2789 self.__field_name=CSVSTRING(value,**{ 'maxsizeinbytes': PB_MAX_NAME_LEN, 'raiseontruncate': False })
2790
2791 def __delfield_name(self): del self.__field_name
2792
2793 name=property(__getfield_name, __setfield_name, __delfield_name, None)
2794
2795 def __getfield_number_type(self):
2796 return self.__field_number_type.getvalue()
2797
2798 def __setfield_number_type(self, value):
2799 if isinstance(value,CSVINT):
2800 self.__field_number_type=value
2801 else:
2802 self.__field_number_type=CSVINT(value,)
2803
2804 def __delfield_number_type(self): del self.__field_number_type
2805
2806 number_type=property(__getfield_number_type, __setfield_number_type, __delfield_number_type, None)
2807
2808 def __getfield_voice_tag(self):
2809 try: self.__field_voice_tag
2810 except:
2811 self.__field_voice_tag=CSVINT(**{ 'default': 0 })
2812 return self.__field_voice_tag.getvalue()
2813
2814 def __setfield_voice_tag(self, value):
2815 if isinstance(value,CSVINT):
2816 self.__field_voice_tag=value
2817 else:
2818 self.__field_voice_tag=CSVINT(value,**{ 'default': 0 })
2819
2820 def __delfield_voice_tag(self): del self.__field_voice_tag
2821
2822 voice_tag=property(__getfield_voice_tag, __setfield_voice_tag, __delfield_voice_tag, None)
2823
2824 def __getfield_ringtone(self):
2825 try: self.__field_ringtone
2826 except:
2827 self.__field_ringtone=CSVINT(**{ 'default': 255 })
2828 return self.__field_ringtone.getvalue()
2829
2830 def __setfield_ringtone(self, value):
2831 if isinstance(value,CSVINT):
2832 self.__field_ringtone=value
2833 else:
2834 self.__field_ringtone=CSVINT(value,**{ 'default': 255 })
2835
2836 def __delfield_ringtone(self): del self.__field_ringtone
2837
2838 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None)
2839
2840 def __getfield_backlight(self):
2841 try: self.__field_backlight
2842 except:
2843 self.__field_backlight=CSVINT(**{ 'default': 0 })
2844 return self.__field_backlight.getvalue()
2845
2846 def __setfield_backlight(self, value):
2847 if isinstance(value,CSVINT):
2848 self.__field_backlight=value
2849 else:
2850 self.__field_backlight=CSVINT(value,**{ 'default': 0 })
2851
2852 def __delfield_backlight(self): del self.__field_backlight
2853
2854 backlight=property(__getfield_backlight, __setfield_backlight, __delfield_backlight, None)
2855
2856 def __getfield_is_primary(self):
2857 try: self.__field_is_primary
2858 except:
2859 self.__field_is_primary=CSVINT(**{ 'default': 0 })
2860 return self.__field_is_primary.getvalue()
2861
2862 def __setfield_is_primary(self, value):
2863 if isinstance(value,CSVINT):
2864 self.__field_is_primary=value
2865 else:
2866 self.__field_is_primary=CSVINT(value,**{ 'default': 0 })
2867
2868 def __delfield_is_primary(self): del self.__field_is_primary
2869
2870 is_primary=property(__getfield_is_primary, __setfield_is_primary, __delfield_is_primary, None)
2871
2872 def __getfield_group(self):
2873 try: self.__field_group
2874 except:
2875 self.__field_group=CSVINT(**{ 'default': 1 })
2876 return self.__field_group.getvalue()
2877
2878 def __setfield_group(self, value):
2879 if isinstance(value,CSVINT):
2880 self.__field_group=value
2881 else:
2882 self.__field_group=CSVINT(value,**{ 'default': 1 })
2883
2884 def __delfield_group(self): del self.__field_group
2885
2886 group=property(__getfield_group, __setfield_group, __delfield_group, None)
2887
2888 def __getfield_icon(self):
2889 try: self.__field_icon
2890 except:
2891 self.__field_icon=CSVINT(**{ 'default': 255 })
2892 return self.__field_icon.getvalue()
2893
2894 def __setfield_icon(self, value):
2895 if isinstance(value,CSVINT):
2896 self.__field_icon=value
2897 else:
2898 self.__field_icon=CSVINT(value,**{ 'default': 255 })
2899
2900 def __delfield_icon(self): del self.__field_icon
2901
2902 icon=property(__getfield_icon, __setfield_icon, __delfield_icon, None)
2903
2904 def __getfield_first_last_enabled(self):
2905 try: self.__field_first_last_enabled
2906 except:
2907 self.__field_first_last_enabled=CSVINT(**{ 'default': 255 })
2908 return self.__field_first_last_enabled.getvalue()
2909
2910 def __setfield_first_last_enabled(self, value):
2911 if isinstance(value,CSVINT):
2912 self.__field_first_last_enabled=value
2913 else:
2914 self.__field_first_last_enabled=CSVINT(value,**{ 'default': 255 })
2915
2916 def __delfield_first_last_enabled(self): del self.__field_first_last_enabled
2917
2918 first_last_enabled=property(__getfield_first_last_enabled, __setfield_first_last_enabled, __delfield_first_last_enabled, None)
2919
2920 def __getfield_subfield_index(self):
2921 try: self.__field_subfield_index
2922 except:
2923 self.__field_subfield_index=CSVINT(**{ 'default': 0 })
2924 return self.__field_subfield_index.getvalue()
2925
2926 def __setfield_subfield_index(self, value):
2927 if isinstance(value,CSVINT):
2928 self.__field_subfield_index=value
2929 else:
2930 self.__field_subfield_index=CSVINT(value,**{ 'default': 0 })
2931
2932 def __delfield_subfield_index(self): del self.__field_subfield_index
2933
2934 subfield_index=property(__getfield_subfield_index, __setfield_subfield_index, __delfield_subfield_index, None)
2935
2936 def __getfield_picture_name(self):
2937 try: self.__field_picture_name
2938 except:
2939 self.__field_picture_name=CSVSTRING(**{ 'terminator': None, 'default': "" })
2940 return self.__field_picture_name.getvalue()
2941
2942 def __setfield_picture_name(self, value):
2943 if isinstance(value,CSVSTRING):
2944 self.__field_picture_name=value
2945 else:
2946 self.__field_picture_name=CSVSTRING(value,**{ 'terminator': None, 'default': "" })
2947
2948 def __delfield_picture_name(self): del self.__field_picture_name
2949
2950 picture_name=property(__getfield_picture_name, __setfield_picture_name, __delfield_picture_name, None)
2951
2952 def iscontainer(self):
2953 return True
2954
2955 def containerelements(self):
2956 yield ('command', self.__field_command, None)
2957 yield ('index', self.__field_index, None)
2958 yield ('number', self.__field_number, None)
2959 yield ('local_type', self.__field_local_type, None)
2960 yield ('name', self.__field_name, None)
2961 yield ('number_type', self.__field_number_type, None)
2962 yield ('voice_tag', self.__field_voice_tag, None)
2963 yield ('ringtone', self.__field_ringtone, None)
2964 yield ('backlight', self.__field_backlight, None)
2965 yield ('is_primary', self.__field_is_primary, None)
2966 yield ('group', self.__field_group, None)
2967 yield ('icon', self.__field_icon, None)
2968 yield ('first_last_enabled', self.__field_first_last_enabled, None)
2969 yield ('subfield_index', self.__field_subfield_index, None)
2970 yield ('picture_name', self.__field_picture_name, None)
2971
2972
2973
2974
2975 class del_pb_req(BaseProtogenClass):
2976 __fields=['command', 'index']
2977
2978 def __init__(self, *args, **kwargs):
2979 dict={}
2980 dict.update(kwargs)
2982 super(del_pb_req,self).__init__(**dict)
2984 if self.__class__ is del_pb_req:
2985 self._update(args,dict)
2986
2987
2988 def getfields(self):
2989 return self.__fields
2990
2991
2992 def _update(self, args, kwargs):
2993 super(del_pb_req,