PyXR

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

0001 # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE
0002 
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 # We use LSB for all integer like fields
0010 UINT=UINTlsb
0011 BOOL=BOOLlsb
0012 
0013 # charset constant
0014 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 # phone mode constant
0025 MODE_MODEM=0
0026 MODE_PHONEBOOK=2
0027 MODE_OBEX=22
0028 
0029 # phonebook constant
0030 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 Stuff
0090 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         # What was supplied to this function
0111         dict.update(kwargs)
0112         # Parent constructor
0113         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         # Were any unrecognized kwargs passed in?
0130         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         # Make all P fields that haven't already been constructed
0138 
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         # What was supplied to this function
0191         dict.update(kwargs)
0192         # Parent constructor
0193         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         # Were any unrecognized kwargs passed in?
0210         if __debug__:
0211             self._complainaboutunusedargs(esnresponse,kwargs)
0212         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0213         # Make all P fields that haven't already been constructed
0214 
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         # What was supplied to this function
0295         dict.update(kwargs)
0296         # Parent constructor
0297         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         # Were any unrecognized kwargs passed in?
0314         if __debug__:
0315             self._complainaboutunusedargs(string_resp,kwargs)
0316         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0317         # Make all P fields that haven't already been constructed
0318 
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         # What was supplied to this function
0382         dict.update(kwargs)
0383         # Parent constructor
0384         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         # Were any unrecognized kwargs passed in?
0401         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         # Make all P fields that haven't already been constructed
0409 
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         # What was supplied to this function
0462         dict.update(kwargs)
0463         # Parent constructor
0464         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         # Were any unrecognized kwargs passed in?
0481         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         # Make all P fields that haven't already been constructed
0489 
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         # What was supplied to this function
0542         dict.update(kwargs)
0543         # Parent constructor
0544         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         # Were any unrecognized kwargs passed in?
0561         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         # Make all P fields that haven't already been constructed
0569 
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         # What was supplied to this function
0622         dict.update(kwargs)
0623         # Parent constructor
0624         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         # Were any unrecognized kwargs passed in?
0641         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         # Make all P fields that haven't already been constructed
0649 
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         # What was supplied to this function
0702         dict.update(kwargs)
0703         # Parent constructor
0704         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         # Were any unrecognized kwargs passed in?
0721         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         # Make all P fields that haven't already been constructed
0729 
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         # What was supplied to this function
0782         dict.update(kwargs)
0783         # Parent constructor
0784         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         # Were any unrecognized kwargs passed in?
0801         if __debug__:
0802             self._complainaboutunusedargs(signal_resp,kwargs)
0803         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0804         # Make all P fields that haven't already been constructed
0805 
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         # What was supplied to this function
0886         dict.update(kwargs)
0887         # Parent constructor
0888         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         # Were any unrecognized kwargs passed in?
0905         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         # Make all P fields that haven't already been constructed
0913 
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         # What was supplied to this function
0966         dict.update(kwargs)
0967         # Parent constructor
0968         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         # Were any unrecognized kwargs passed in?
0985         if __debug__:
0986             self._complainaboutunusedargs(battery_resp,kwargs)
0987         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0988         # Make all P fields that haven't already been constructed
0989 
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         # What was supplied to this function
1070         dict.update(kwargs)
1071         # Parent constructor
1072         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         # Were any unrecognized kwargs passed in?
1089         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         # Make all P fields that haven't already been constructed
1097 
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         # What was supplied to this function
1150         dict.update(kwargs)
1151         # Parent constructor
1152         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         # Were any unrecognized kwargs passed in?
1169         if __debug__:
1170             self._complainaboutunusedargs(moderesp,kwargs)
1171         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1172         # Make all P fields that haven't already been constructed
1173 
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         # What was supplied to this function
1237         dict.update(kwargs)
1238         # Parent constructor
1239         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         # Were any unrecognized kwargs passed in?
1256         if __debug__:
1257             self._complainaboutunusedargs(modeset,kwargs)
1258         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1259         # Make all P fields that haven't already been constructed
1260 
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         # What was supplied to this function
1336         dict.update(kwargs)
1337         # Parent constructor
1338         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         # Were any unrecognized kwargs passed in?
1355         if __debug__:
1356             self._complainaboutunusedargs(charset_set_req,kwargs)
1357         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1358         # Make all P fields that haven't already been constructed
1359 
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         # What was supplied to this function
1435         dict.update(kwargs)
1436         # Parent constructor
1437         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         # Were any unrecognized kwargs passed in?
1454         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         # Make all P fields that haven't already been constructed
1462 
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         # What was supplied to this function
1515         dict.update(kwargs)
1516         # Parent constructor
1517         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         # Were any unrecognized kwargs passed in?
1534         if __debug__:
1535             self._complainaboutunusedargs(featureresp,kwargs)
1536         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1537         # Make all P fields that haven't already been constructed
1538 
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         # What was supplied to this function
1795         dict.update(kwargs)
1796         # Parent constructor
1797         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         # Were any unrecognized kwargs passed in?
1814         if __debug__:
1815             self._complainaboutunusedargs(select_phonebook_req,kwargs)
1816         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1817         # Make all P fields that haven't already been constructed
1818 
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         # What was supplied to this function
1894         dict.update(kwargs)
1895         # Parent constructor
1896         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         # Were any unrecognized kwargs passed in?
1913         if __debug__:
1914             self._complainaboutunusedargs(read_pb_simple_req,kwargs)
1915         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1916         # Make all P fields that haven't already been constructed
1917 
1918 
1919     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1920         'Writes this packet to the supplied buffer'
1921         self._bufferstartoffset=buf.getcurrentoffset()
1922         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         # What was supplied to this function
2016         dict.update(kwargs)
2017         # Parent constructor
2018         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         # Were any unrecognized kwargs passed in?
2035         if __debug__:
2036             self._complainaboutunusedargs(read_pb_simple_resp,kwargs)
2037         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2038         # Make all P fields that haven't already been constructed
2039 
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         # What was supplied to this function
2160         dict.update(kwargs)
2161         # Parent constructor
2162         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         # Were any unrecognized kwargs passed in?
2179         if __debug__:
2180             self._complainaboutunusedargs(read_pb_req,kwargs)
2181         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2182         # Make all P fields that haven't already been constructed
2183 
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         # What was supplied to this function
2282         dict.update(kwargs)
2283         # Parent constructor
2284         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         # Were any unrecognized kwargs passed in?
2301         if __debug__:
2302             self._complainaboutunusedargs(read_pb_resp,kwargs)
2303         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2304         # Make all P fields that haven't already been constructed
2305 
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         # What was supplied to this function
2607         dict.update(kwargs)
2608         # Parent constructor
2609         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         # Were any unrecognized kwargs passed in?
2626         if __debug__:
2627             self._complainaboutunusedargs(write_pb_req,kwargs)
2628         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2629         # Make all P fields that haven't already been constructed
2630 
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         # What was supplied to this function
2981         dict.update(kwargs)
2982         # Parent constructor
2983         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,self)._update(args,kwargs)
2994         keys=kwargs.keys()
2995         for key in keys:
2996             if key in self.__fields:
2997                 setattr(self, key, kwargs[key])
2998                 del kwargs[key]
2999         # Were any unrecognized kwargs passed in?
3000         if __debug__:
3001             self._complainaboutunusedargs(del_pb_req,kwargs)
3002         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3003         # Make all P fields that haven't already been constructed
3004 
3005 
3006     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3007         'Writes this packet to the supplied buffer'
3008         self._bufferstartoffset=buf.getcurrentoffset()
3009         try: self.__field_command
3010         except:
3011             self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None,                  'default': '+MPBW=' })
3012         self.__field_command.writetobuffer(buf)
3013         self.__field_index.writetobuffer(buf)
3014         self._bufferendoffset=buf.getcurrentoffset()
3015         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3016 
3017 
3018     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3019         'Reads this packet from the supplied buffer'
3020         self._bufferstartoffset=buf.getcurrentoffset()
3021         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3022         self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None,                  'default': '+MPBW=' })
3023         self.__field_command.readfrombuffer(buf)
3024         self.__field_index=CSVINT(**{ 'terminator': None })
3025         self.__field_index.readfrombuffer(buf)
3026         self._bufferendoffset=buf.getcurrentoffset()
3027 
3028 
3029     def __getfield_command(self):
3030         try: self.__field_command
3031         except:
3032             self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None,                  'default': '+MPBW=' })
3033         return self.__field_command.getvalue()
3034 
3035     def __setfield_command(self, value):
3036         if isinstance(value,CSVSTRING):
3037             self.__field_command=value
3038         else:
3039             self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None,                  'default': '+MPBW=' })
3040 
3041     def __delfield_command(self): del self.__field_command
3042 
3043     command=property(__getfield_command, __setfield_command, __delfield_command, None)
3044 
3045     def __getfield_index(self):
3046         return self.__field_index.getvalue()
3047 
3048     def __setfield_index(self, value):
3049         if isinstance(value,CSVINT):
3050             self.__field_index=value
3051         else:
3052             self.__field_index=CSVINT(value,**{ 'terminator': None })
3053 
3054     def __delfield_index(self): del self.__field_index
3055 
3056     index=property(__getfield_index, __setfield_index, __delfield_index, None)
3057 
3058     def iscontainer(self):
3059         return True
3060 
3061     def containerelements(self):
3062         yield ('command', self.__field_command, None)
3063         yield ('index', self.__field_index, None)
3064 
3065 
3066 
3067 
3068 class sms_sel_req(BaseProtogenClass):
3069     __fields=['command', 'mem1', 'mem2', 'mem3']
3070 
3071     def __init__(self, *args, **kwargs):
3072         dict={}
3073         # What was supplied to this function
3074         dict.update(kwargs)
3075         # Parent constructor
3076         super(sms_sel_req,self).__init__(**dict)
3077         if self.__class__ is sms_sel_req:
3078             self._update(args,dict)
3079 
3080 
3081     def getfields(self):
3082         return self.__fields
3083 
3084 
3085     def _update(self, args, kwargs):
3086         super(sms_sel_req,self)._update(args,kwargs)
3087         keys=kwargs.keys()
3088         for key in keys:
3089             if key in self.__fields:
3090                 setattr(self, key, kwargs[key])
3091                 del kwargs[key]
3092         # Were any unrecognized kwargs passed in?
3093         if __debug__:
3094             self._complainaboutunusedargs(sms_sel_req,kwargs)
3095         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3096         # Make all P fields that haven't already been constructed
3097 
3098 
3099     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3100         'Writes this packet to the supplied buffer'
3101         self._bufferstartoffset=buf.getcurrentoffset()
3102         try: self.__field_command
3103         except:
3104             self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None,                  'default': '+CPMS=' })
3105         self.__field_command.writetobuffer(buf)
3106         try: self.__field_mem1
3107         except:
3108             self.__field_mem1=CSVSTRING(**{ 'default': SMS_COMBINE })
3109         self.__field_mem1.writetobuffer(buf)
3110         try: self.__field_mem2
3111         except:
3112             self.__field_mem2=CSVSTRING(**{ 'default': SMS_OUTBOX })
3113         self.__field_mem2.writetobuffer(buf)
3114         try: self.__field_mem3
3115         except:
3116             self.__field_mem3=CSVSTRING(**{ 'terminator': None,                  'default': SMS_INBOX })
3117         self.__field_mem3.writetobuffer(buf)
3118         self._bufferendoffset=buf.getcurrentoffset()
3119         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3120 
3121 
3122     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3123         'Reads this packet from the supplied buffer'
3124         self._bufferstartoffset=buf.getcurrentoffset()
3125         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3126         self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None,                  'default': '+CPMS=' })
3127         self.__field_command.readfrombuffer(buf)
3128         self.__field_mem1=CSVSTRING(**{ 'default': SMS_COMBINE })
3129         self.__field_mem1.readfrombuffer(buf)
3130         self.__field_mem2=CSVSTRING(**{ 'default': SMS_OUTBOX })
3131         self.__field_mem2.readfrombuffer(buf)
3132         self.__field_mem3=CSVSTRING(**{ 'terminator': None,                  'default': SMS_INBOX })
3133         self.__field_mem3.readfrombuffer(buf)
3134         self._bufferendoffset=buf.getcurrentoffset()
3135 
3136 
3137     def __getfield_command(self):
3138         try: self.__field_command
3139         except:
3140             self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None,                  'default': '+CPMS=' })
3141         return self.__field_command.getvalue()
3142 
3143     def __setfield_command(self, value):
3144         if isinstance(value,CSVSTRING):
3145             self.__field_command=value
3146         else:
3147             self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None,                  'default': '+CPMS=' })
3148 
3149     def __delfield_command(self): del self.__field_command
3150 
3151     command=property(__getfield_command, __setfield_command, __delfield_command, None)
3152 
3153     def __getfield_mem1(self):
3154         try: self.__field_mem1
3155         except:
3156             self.__field_mem1=CSVSTRING(**{ 'default': SMS_COMBINE })
3157         return self.__field_mem1.getvalue()
3158 
3159     def __setfield_mem1(self, value):
3160         if isinstance(value,CSVSTRING):
3161             self.__field_mem1=value
3162         else:
3163             self.__field_mem1=CSVSTRING(value,**{ 'default': SMS_COMBINE })
3164 
3165     def __delfield_mem1(self): del self.__field_mem1
3166 
3167     mem1=property(__getfield_mem1, __setfield_mem1, __delfield_mem1, None)
3168 
3169     def __getfield_mem2(self):
3170         try: self.__field_mem2
3171         except:
3172             self.__field_mem2=CSVSTRING(**{ 'default': SMS_OUTBOX })
3173         return self.__field_mem2.getvalue()
3174 
3175     def __setfield_mem2(self, value):
3176         if isinstance(value,CSVSTRING):
3177             self.__field_mem2=value
3178         else:
3179             self.__field_mem2=CSVSTRING(value,**{ 'default': SMS_OUTBOX })
3180 
3181     def __delfield_mem2(self): del self.__field_mem2
3182 
3183     mem2=property(__getfield_mem2, __setfield_mem2, __delfield_mem2, None)
3184 
3185     def __getfield_mem3(self):
3186         try: self.__field_mem3
3187         except:
3188             self.__field_mem3=CSVSTRING(**{ 'terminator': None,                  'default': SMS_INBOX })
3189         return self.__field_mem3.getvalue()
3190 
3191     def __setfield_mem3(self, value):
3192         if isinstance(value,CSVSTRING):
3193             self.__field_mem3=value
3194         else:
3195             self.__field_mem3=CSVSTRING(value,**{ 'terminator': None,                  'default': SMS_INBOX })
3196 
3197     def __delfield_mem3(self): del self.__field_mem3
3198 
3199     mem3=property(__getfield_mem3, __setfield_mem3, __delfield_mem3, None)
3200 
3201     def iscontainer(self):
3202         return True
3203 
3204     def containerelements(self):
3205         yield ('command', self.__field_command, None)
3206         yield ('mem1', self.__field_mem1, None)
3207         yield ('mem2', self.__field_mem2, None)
3208         yield ('mem3', self.__field_mem3, None)
3209 
3210 
3211 
3212 
3213 class sms_m_read_resp(BaseProtogenClass):
3214     __fields=['command', 'has_date', 'date_terminated', 'sms_type', 'sms_addr', 'sms_date', 'sms_date', 'sms_addr']
3215 
3216     def __init__(self, *args, **kwargs):
3217         dict={}
3218         # What was supplied to this function
3219         dict.update(kwargs)
3220         # Parent constructor
3221         super(sms_m_read_resp,self).__init__(**dict)
3222         if self.__class__ is sms_m_read_resp:
3223             self._update(args,dict)
3224 
3225 
3226     def getfields(self):
3227         return self.__fields
3228 
3229 
3230     def _update(self, args, kwargs):
3231         super(sms_m_read_resp,self)._update(args,kwargs)
3232         keys=kwargs.keys()
3233         for key in keys:
3234             if key in self.__fields:
3235                 setattr(self, key, kwargs[key])
3236                 del kwargs[key]
3237         # Were any unrecognized kwargs passed in?
3238         if __debug__:
3239             self._complainaboutunusedargs(sms_m_read_resp,kwargs)
3240         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3241         # Make all P fields that haven't already been constructed
3242         try: self.__field_has_date
3243         except:
3244             self.__field_has_date=BOOL(**{ 'default': True })
3245         try: self.__field_date_terminated
3246         except:
3247             self.__field_date_terminated=BOOL(**{ 'default': False })
3248 
3249 
3250     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3251         'Writes this packet to the supplied buffer'
3252         self._bufferstartoffset=buf.getcurrentoffset()
3253         self.__field_command.writetobuffer(buf)
3254         self.__field_sms_type.writetobuffer(buf)
3255         if self.has_date:
3256             self.__field_sms_addr.writetobuffer(buf)
3257             if self.date_terminated:
3258                 self.__field_sms_date.writetobuffer(buf)
3259             else:
3260                 self.__field_sms_date.writetobuffer(buf)
3261         else:
3262             self.__field_sms_addr.writetobuffer(buf)
3263         self._bufferendoffset=buf.getcurrentoffset()
3264         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3265 
3266 
3267     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3268         'Reads this packet from the supplied buffer'
3269         self._bufferstartoffset=buf.getcurrentoffset()
3270         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3271         self.__field_command=CSVSTRING(**{ 'quotechar': None,                  'terminator': ord(' '),                  'default': '+MMGR:' })
3272         self.__field_command.readfrombuffer(buf)
3273         self.__field_sms_type=CSVSTRING()
3274         self.__field_sms_type.readfrombuffer(buf)
3275         if self.has_date:
3276             self.__field_sms_addr=CSVSTRING(**{ 'quotechar': None })
3277             self.__field_sms_addr.readfrombuffer(buf)
3278             if self.date_terminated:
3279                 self.__field_sms_date=M_SMSDATETIME()
3280                 self.__field_sms_date.readfrombuffer(buf)
3281             else:
3282                 self.__field_sms_date=M_SMSDATETIME(**{ 'quotechar': None,                              'terminator': None })
3283                 self.__field_sms_date.readfrombuffer(buf)
3284         else:
3285             self.__field_sms_addr=CSVSTRING(**{ 'terminator': None,                      'quotechar': None })
3286             self.__field_sms_addr.readfrombuffer(buf)
3287         self._bufferendoffset=buf.getcurrentoffset()
3288 
3289 
3290     def __getfield_command(self):
3291         return self.__field_command.getvalue()
3292 
3293     def __setfield_command(self, value):
3294         if isinstance(value,CSVSTRING):
3295             self.__field_command=value
3296         else:
3297             self.__field_command=CSVSTRING(value,**{ 'quotechar': None,                  'terminator': ord(' '),                  'default': '+MMGR:' })
3298 
3299     def __delfield_command(self): del self.__field_command
3300 
3301     command=property(__getfield_command, __setfield_command, __delfield_command, None)
3302 
3303     def __getfield_has_date(self):
3304         try: self.__field_has_date
3305         except:
3306             self.__field_has_date=BOOL(**{ 'default': True })
3307         return self.__field_has_date.getvalue()
3308 
3309     def __setfield_has_date(self, value):
3310         if isinstance(value,BOOL):
3311             self.__field_has_date=value
3312         else:
3313             self.__field_has_date=BOOL(value,**{ 'default': True })
3314 
3315     def __delfield_has_date(self): del self.__field_has_date
3316 
3317     has_date=property(__getfield_has_date, __setfield_has_date, __delfield_has_date, None)
3318 
3319     def __getfield_date_terminated(self):
3320         try: self.__field_date_terminated
3321         except:
3322             self.__field_date_terminated=BOOL(**{ 'default': False })
3323         return self.__field_date_terminated.getvalue()
3324 
3325     def __setfield_date_terminated(self, value):
3326         if isinstance(value,BOOL):
3327             self.__field_date_terminated=value
3328         else:
3329             self.__field_date_terminated=BOOL(value,**{ 'default': False })
3330 
3331     def __delfield_date_terminated(self): del self.__field_date_terminated
3332 
3333     date_terminated=property(__getfield_date_terminated, __setfield_date_terminated, __delfield_date_terminated, None)
3334 
3335     def __getfield_sms_type(self):
3336         return self.__field_sms_type.getvalue()
3337 
3338     def __setfield_sms_type(self, value):
3339         if isinstance(value,CSVSTRING):
3340             self.__field_sms_type=value
3341         else:
3342             self.__field_sms_type=CSVSTRING(value,)
3343 
3344     def __delfield_sms_type(self): del self.__field_sms_type
3345 
3346     sms_type=property(__getfield_sms_type, __setfield_sms_type, __delfield_sms_type, None)
3347 
3348     def __getfield_sms_addr(self):
3349         return self.__field_sms_addr.getvalue()
3350 
3351     def __setfield_sms_addr(self, value):
3352         if isinstance(value,CSVSTRING):
3353             self.__field_sms_addr=value
3354         else:
3355             self.__field_sms_addr=CSVSTRING(value,**{ 'quotechar': None })
3356 
3357     def __delfield_sms_addr(self): del self.__field_sms_addr
3358 
3359     sms_addr=property(__getfield_sms_addr, __setfield_sms_addr, __delfield_sms_addr, None)
3360 
3361     def __getfield_sms_date(self):
3362         return self.__field_sms_date.getvalue()
3363 
3364     def __setfield_sms_date(self, value):
3365         if isinstance(value,M_SMSDATETIME):
3366             self.__field_sms_date=value
3367         else:
3368             self.__field_sms_date=M_SMSDATETIME(value,)
3369 
3370     def __delfield_sms_date(self): del self.__field_sms_date
3371 
3372     sms_date=property(__getfield_sms_date, __setfield_sms_date, __delfield_sms_date, None)
3373 
3374     def __getfield_sms_date(self):
3375         return self.__field_sms_date.getvalue()
3376 
3377     def __setfield_sms_date(self, value):
3378         if isinstance(value,M_SMSDATETIME):
3379             self.__field_sms_date=value
3380         else:
3381             self.__field_sms_date=M_SMSDATETIME(value,**{ 'quotechar': None,                              'terminator': None })
3382 
3383     def __delfield_sms_date(self): del self.__field_sms_date
3384 
3385     sms_date=property(__getfield_sms_date, __setfield_sms_date, __delfield_sms_date, None)
3386 
3387     def __getfield_sms_addr(self):
3388         return self.__field_sms_addr.getvalue()
3389 
3390     def __setfield_sms_addr(self, value):
3391         if isinstance(value,CSVSTRING):
3392             self.__field_sms_addr=value
3393         else:
3394             self.__field_sms_addr=CSVSTRING(value,**{ 'terminator': None,                      'quotechar': None })
3395 
3396     def __delfield_sms_addr(self): del self.__field_sms_addr
3397 
3398     sms_addr=property(__getfield_sms_addr, __setfield_sms_addr, __delfield_sms_addr, None)
3399 
3400     def iscontainer(self):
3401         return True
3402 
3403     def containerelements(self):
3404         yield ('command', self.__field_command, None)
3405         yield ('has_date', self.__field_has_date, None)
3406         yield ('date_terminated', self.__field_date_terminated, None)
3407         yield ('sms_type', self.__field_sms_type, None)
3408         if self.has_date:
3409             yield ('sms_addr', self.__field_sms_addr, None)
3410             if self.date_terminated:
3411                 yield ('sms_date', self.__field_sms_date, None)
3412             else:
3413                 yield ('sms_date', self.__field_sms_date, None)
3414         else:
3415             yield ('sms_addr', self.__field_sms_addr, None)
3416 
3417 
3418 
3419 
3420 class sms_list_req(BaseProtogenClass):
3421     __fields=['command', 'listtype']
3422 
3423     def __init__(self, *args, **kwargs):
3424         dict={}
3425         # What was supplied to this function
3426         dict.update(kwargs)
3427         # Parent constructor
3428         super(sms_list_req,self).__init__(**dict)
3429         if self.__class__ is sms_list_req:
3430             self._update(args,dict)
3431 
3432 
3433     def getfields(self):
3434         return self.__fields
3435 
3436 
3437     def _update(self, args, kwargs):
3438         super(sms_list_req,self)._update(args,kwargs)
3439         keys=kwargs.keys()
3440         for key in keys:
3441             if key in self.__fields:
3442                 setattr(self, key, kwargs[key])
3443                 del kwargs[key]
3444         # Were any unrecognized kwargs passed in?
3445         if __debug__:
3446             self._complainaboutunusedargs(sms_list_req,kwargs)
3447         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3448         # Make all P fields that haven't already been constructed
3449 
3450 
3451     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3452         'Writes this packet to the supplied buffer'
3453         self._bufferstartoffset=buf.getcurrentoffset()
3454         try: self.__field_command
3455         except:
3456             self.__field_command=CSVSTRING(**{ 'quotechar': None,                  'terminator': None,                  'default': '+MMGL=' })
3457         self.__field_command.writetobuffer(buf)
3458         try: self.__field_listtype
3459         except:
3460             self.__field_listtype=CSVSTRING(**{ 'terminator': None,                  'default': SMS_HEADER_ONLY })
3461         self.__field_listtype.writetobuffer(buf)
3462         self._bufferendoffset=buf.getcurrentoffset()
3463         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3464 
3465 
3466     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3467         'Reads this packet from the supplied buffer'
3468         self._bufferstartoffset=buf.getcurrentoffset()
3469         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3470         self.__field_command=CSVSTRING(**{ 'quotechar': None,                  'terminator': None,                  'default': '+MMGL=' })
3471         self.__field_command.readfrombuffer(buf)
3472         self.__field_listtype=CSVSTRING(**{ 'terminator': None,                  'default': SMS_HEADER_ONLY })
3473         self.__field_listtype.readfrombuffer(buf)
3474         self._bufferendoffset=buf.getcurrentoffset()
3475 
3476 
3477     def __getfield_command(self):
3478         try: self.__field_command
3479         except:
3480             self.__field_command=CSVSTRING(**{ 'quotechar': None,                  'terminator': None,                  'default': '+MMGL=' })
3481         return self.__field_command.getvalue()
3482 
3483     def __setfield_command(self, value):
3484         if isinstance(value,CSVSTRING):
3485             self.__field_command=value
3486         else:
3487             self.__field_command=CSVSTRING(value,**{ 'quotechar': None,                  'terminator': None,                  'default': '+MMGL=' })
3488 
3489     def __delfield_command(self): del self.__field_command
3490 
3491     command=property(__getfield_command, __setfield_command, __delfield_command, None)
3492 
3493     def __getfield_listtype(self):
3494         try: self.__field_listtype
3495         except:
3496             self.__field_listtype=CSVSTRING(**{ 'terminator': None,                  'default': SMS_HEADER_ONLY })
3497         return self.__field_listtype.getvalue()
3498 
3499     def __setfield_listtype(self, value):
3500         if isinstance(value,CSVSTRING):
3501             self.__field_listtype=value
3502         else:
3503             self.__field_listtype=CSVSTRING(value,**{ 'terminator': None,                  'default': SMS_HEADER_ONLY })
3504 
3505     def __delfield_listtype(self): del self.__field_listtype
3506 
3507     listtype=property(__getfield_listtype, __setfield_listtype, __delfield_listtype, None)
3508 
3509     def iscontainer(self):
3510         return True
3511 
3512     def containerelements(self):
3513         yield ('command', self.__field_command, None)
3514         yield ('listtype', self.__field_listtype, None)
3515 
3516 
3517 
3518 
3519 class sms_list_resp(BaseProtogenClass):
3520     __fields=['command', 'index', 'dontcare']
3521 
3522     def __init__(self, *args, **kwargs):
3523         dict={}
3524         # What was supplied to this function
3525         dict.update(kwargs)
3526         # Parent constructor
3527         super(sms_list_resp,self).__init__(**dict)
3528         if self.__class__ is sms_list_resp:
3529             self._update(args,dict)
3530 
3531 
3532     def getfields(self):
3533         return self.__fields
3534 
3535 
3536     def _update(self, args, kwargs):
3537         super(sms_list_resp,self)._update(args,kwargs)
3538         keys=kwargs.keys()
3539         for key in keys:
3540             if key in self.__fields:
3541                 setattr(self, key, kwargs[key])
3542                 del kwargs[key]
3543         # Were any unrecognized kwargs passed in?
3544         if __debug__:
3545             self._complainaboutunusedargs(sms_list_resp,kwargs)
3546         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3547         # Make all P fields that haven't already been constructed
3548 
3549 
3550     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3551         'Writes this packet to the supplied buffer'
3552         self._bufferstartoffset=buf.getcurrentoffset()
3553         self.__field_command.writetobuffer(buf)
3554         self.__field_index.writetobuffer(buf)
3555         self.__field_dontcare.writetobuffer(buf)
3556         self._bufferendoffset=buf.getcurrentoffset()
3557         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3558 
3559 
3560     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3561         'Reads this packet from the supplied buffer'
3562         self._bufferstartoffset=buf.getcurrentoffset()
3563         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3564         self.__field_command=CSVSTRING(**{ 'quotechar': None,                  'terminator': ord(' '),                  'default': '+MMGL:' })
3565         self.__field_command.readfrombuffer(buf)
3566         self.__field_index=CSVINT()
3567         self.__field_index.readfrombuffer(buf)
3568         self.__field_dontcare=DATA()
3569         self.__field_dontcare.readfrombuffer(buf)
3570         self._bufferendoffset=buf.getcurrentoffset()
3571 
3572 
3573     def __getfield_command(self):
3574         return self.__field_command.getvalue()
3575 
3576     def __setfield_command(self, value):
3577         if isinstance(value,CSVSTRING):
3578             self.__field_command=value
3579         else:
3580             self.__field_command=CSVSTRING(value,**{ 'quotechar': None,                  'terminator': ord(' '),                  'default': '+MMGL:' })
3581 
3582     def __delfield_command(self): del self.__field_command
3583 
3584     command=property(__getfield_command, __setfield_command, __delfield_command, None)
3585 
3586     def __getfield_index(self):
3587         return self.__field_index.getvalue()
3588 
3589     def __setfield_index(self, value):
3590         if isinstance(value,CSVINT):
3591             self.__field_index=value
3592         else:
3593             self.__field_index=CSVINT(value,)
3594 
3595     def __delfield_index(self): del self.__field_index
3596 
3597     index=property(__getfield_index, __setfield_index, __delfield_index, None)
3598 
3599     def __getfield_dontcare(self):
3600         return self.__field_dontcare.getvalue()
3601 
3602     def __setfield_dontcare(self, value):
3603         if isinstance(value,DATA):
3604             self.__field_dontcare=value
3605         else:
3606             self.__field_dontcare=DATA(value,)
3607 
3608     def __delfield_dontcare(self): del self.__field_dontcare
3609 
3610     dontcare=property(__getfield_dontcare, __setfield_dontcare, __delfield_dontcare, None)
3611 
3612     def iscontainer(self):
3613         return True
3614 
3615     def containerelements(self):
3616         yield ('command', self.__field_command, None)
3617         yield ('index', self.__field_index, None)
3618         yield ('dontcare', self.__field_dontcare, None)
3619 
3620 
3621 
3622 
3623