PyXR

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

0001 # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE
0002 
0003 """Various descriptions of data specific to Audiovox CDM8900"""
0004 
0005 from prototypes import *
0006 
0007 # We use LSB for all integer like fields
0008 UINT=UINTlsb
0009 BOOL=BOOLlsb
0010 
0011 _NUMSLOTS=300
0012 _NUMGROUPS=7
0013 _ALLGROUP=0
0014 _MAXGROUPLEN=16
0015 _MAXPHONENUMBERLEN=32
0016 _MAXNAMELEN=16
0017 _MAXEMAILLEN=48
0018 _MAXMEMOLEN=48
0019 class readpbslotsrequest(BaseProtogenClass):
0020     "Get a list of which slots are used"
0021     __fields=['cmd']
0022 
0023     def __init__(self, *args, **kwargs):
0024         dict={}
0025         # What was supplied to this function
0026         dict.update(kwargs)
0027         # Parent constructor
0028         super(readpbslotsrequest,self).__init__(**dict)
0029         if self.__class__ is readpbslotsrequest:
0030             self._update(args,dict)
0031 
0032 
0033     def getfields(self):
0034         return self.__fields
0035 
0036 
0037     def _update(self, args, kwargs):
0038         super(readpbslotsrequest,self)._update(args,kwargs)
0039         keys=kwargs.keys()
0040         for key in keys:
0041             if key in self.__fields:
0042                 setattr(self, key, kwargs[key])
0043                 del kwargs[key]
0044         # Were any unrecognized kwargs passed in?
0045         if __debug__:
0046             self._complainaboutunusedargs(readpbslotsrequest,kwargs)
0047         if len(args):
0048             dict2={'sizeinbytes': 1, 'constant': 0x85}
0049             dict2.update(kwargs)
0050             kwargs=dict2
0051             self.__field_cmd=UINT(*args,**dict2)
0052         # Make all P fields that haven't already been constructed
0053 
0054 
0055     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0056         'Writes this packet to the supplied buffer'
0057         self._bufferstartoffset=buf.getcurrentoffset()
0058         try: self.__field_cmd
0059         except:
0060             self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x85})
0061         self.__field_cmd.writetobuffer(buf)
0062         self._bufferendoffset=buf.getcurrentoffset()
0063         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0064 
0065 
0066     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0067         'Reads this packet from the supplied buffer'
0068         self._bufferstartoffset=buf.getcurrentoffset()
0069         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0070         self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x85})
0071         self.__field_cmd.readfrombuffer(buf)
0072         self._bufferendoffset=buf.getcurrentoffset()
0073 
0074 
0075     def __getfield_cmd(self):
0076         try: self.__field_cmd
0077         except:
0078             self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x85})
0079         return self.__field_cmd.getvalue()
0080 
0081     def __setfield_cmd(self, value):
0082         if isinstance(value,UINT):
0083             self.__field_cmd=value
0084         else:
0085             self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'constant': 0x85})
0086 
0087     def __delfield_cmd(self): del self.__field_cmd
0088 
0089     cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None)
0090 
0091     def iscontainer(self):
0092         return True
0093 
0094     def containerelements(self):
0095         yield ('cmd', self.__field_cmd, None)
0096 
0097 
0098 
0099 
0100 class readpbslotsresponse(BaseProtogenClass):
0101     __fields=['cmd', 'present']
0102 
0103     def __init__(self, *args, **kwargs):
0104         dict={}
0105         # What was supplied to this function
0106         dict.update(kwargs)
0107         # Parent constructor
0108         super(readpbslotsresponse,self).__init__(**dict)
0109         if self.__class__ is readpbslotsresponse:
0110             self._update(args,dict)
0111 
0112 
0113     def getfields(self):
0114         return self.__fields
0115 
0116 
0117     def _update(self, args, kwargs):
0118         super(readpbslotsresponse,self)._update(args,kwargs)
0119         keys=kwargs.keys()
0120         for key in keys:
0121             if key in self.__fields:
0122                 setattr(self, key, kwargs[key])
0123                 del kwargs[key]
0124         # Were any unrecognized kwargs passed in?
0125         if __debug__:
0126             self._complainaboutunusedargs(readpbslotsresponse,kwargs)
0127         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0128         # Make all P fields that haven't already been constructed
0129 
0130 
0131     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0132         'Writes this packet to the supplied buffer'
0133         self._bufferstartoffset=buf.getcurrentoffset()
0134         self.__field_cmd.writetobuffer(buf)
0135         self.__field_present.writetobuffer(buf)
0136         self._bufferendoffset=buf.getcurrentoffset()
0137         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0138 
0139 
0140     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0141         'Reads this packet from the supplied buffer'
0142         self._bufferstartoffset=buf.getcurrentoffset()
0143         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0144         self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x85})
0145         self.__field_cmd.readfrombuffer(buf)
0146         self.__field_present=DATA()
0147         self.__field_present.readfrombuffer(buf)
0148         self._bufferendoffset=buf.getcurrentoffset()
0149 
0150 
0151     def __getfield_cmd(self):
0152         return self.__field_cmd.getvalue()
0153 
0154     def __setfield_cmd(self, value):
0155         if isinstance(value,UINT):
0156             self.__field_cmd=value
0157         else:
0158             self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'constant': 0x85})
0159 
0160     def __delfield_cmd(self): del self.__field_cmd
0161 
0162     cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None)
0163 
0164     def __getfield_present(self):
0165         return self.__field_present.getvalue()
0166 
0167     def __setfield_present(self, value):
0168         if isinstance(value,DATA):
0169             self.__field_present=value
0170         else:
0171             self.__field_present=DATA(value,)
0172 
0173     def __delfield_present(self): del self.__field_present
0174 
0175     present=property(__getfield_present, __setfield_present, __delfield_present, "a non-zero value indicates a slot is present")
0176 
0177     def iscontainer(self):
0178         return True
0179 
0180     def containerelements(self):
0181         yield ('cmd', self.__field_cmd, None)
0182         yield ('present', self.__field_present, "a non-zero value indicates a slot is present")
0183 
0184 
0185 
0186 
0187 class writepbslotsrequest(BaseProtogenClass):
0188     __fields=['cmd', 'present']
0189 
0190     def __init__(self, *args, **kwargs):
0191         dict={}
0192         # What was supplied to this function
0193         dict.update(kwargs)
0194         # Parent constructor
0195         super(writepbslotsrequest,self).__init__(**dict)
0196         if self.__class__ is writepbslotsrequest:
0197             self._update(args,dict)
0198 
0199 
0200     def getfields(self):
0201         return self.__fields
0202 
0203 
0204     def _update(self, args, kwargs):
0205         super(writepbslotsrequest,self)._update(args,kwargs)
0206         keys=kwargs.keys()
0207         for key in keys:
0208             if key in self.__fields:
0209                 setattr(self, key, kwargs[key])
0210                 del kwargs[key]
0211         # Were any unrecognized kwargs passed in?
0212         if __debug__:
0213             self._complainaboutunusedargs(writepbslotsrequest,kwargs)
0214         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0215         # Make all P fields that haven't already been constructed
0216 
0217 
0218     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0219         'Writes this packet to the supplied buffer'
0220         self._bufferstartoffset=buf.getcurrentoffset()
0221         try: self.__field_cmd
0222         except:
0223             self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x84})
0224         self.__field_cmd.writetobuffer(buf)
0225         self.__field_present.writetobuffer(buf)
0226         self._bufferendoffset=buf.getcurrentoffset()
0227         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0228 
0229 
0230     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0231         'Reads this packet from the supplied buffer'
0232         self._bufferstartoffset=buf.getcurrentoffset()
0233         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0234         self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x84})
0235         self.__field_cmd.readfrombuffer(buf)
0236         self.__field_present=DATA()
0237         self.__field_present.readfrombuffer(buf)
0238         self._bufferendoffset=buf.getcurrentoffset()
0239 
0240 
0241     def __getfield_cmd(self):
0242         try: self.__field_cmd
0243         except:
0244             self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x84})
0245         return self.__field_cmd.getvalue()
0246 
0247     def __setfield_cmd(self, value):
0248         if isinstance(value,UINT):
0249             self.__field_cmd=value
0250         else:
0251             self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'constant': 0x84})
0252 
0253     def __delfield_cmd(self): del self.__field_cmd
0254 
0255     cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None)
0256 
0257     def __getfield_present(self):
0258         return self.__field_present.getvalue()
0259 
0260     def __setfield_present(self, value):
0261         if isinstance(value,DATA):
0262             self.__field_present=value
0263         else:
0264             self.__field_present=DATA(value,)
0265 
0266     def __delfield_present(self): del self.__field_present
0267 
0268     present=property(__getfield_present, __setfield_present, __delfield_present, "a non-zero value indicates a slot is present")
0269 
0270     def iscontainer(self):
0271         return True
0272 
0273     def containerelements(self):
0274         yield ('cmd', self.__field_cmd, None)
0275         yield ('present', self.__field_present, "a non-zero value indicates a slot is present")
0276 
0277 
0278 
0279 
0280 class writepbslotsresponse(BaseProtogenClass):
0281     __fields=['cmd']
0282 
0283     def __init__(self, *args, **kwargs):
0284         dict={}
0285         # What was supplied to this function
0286         dict.update(kwargs)
0287         # Parent constructor
0288         super(writepbslotsresponse,self).__init__(**dict)
0289         if self.__class__ is writepbslotsresponse:
0290             self._update(args,dict)
0291 
0292 
0293     def getfields(self):
0294         return self.__fields
0295 
0296 
0297     def _update(self, args, kwargs):
0298         super(writepbslotsresponse,self)._update(args,kwargs)
0299         keys=kwargs.keys()
0300         for key in keys:
0301             if key in self.__fields:
0302                 setattr(self, key, kwargs[key])
0303                 del kwargs[key]
0304         # Were any unrecognized kwargs passed in?
0305         if __debug__:
0306             self._complainaboutunusedargs(writepbslotsresponse,kwargs)
0307         if len(args):
0308             dict2={'sizeinbytes': 1, 'constant': 0x84}
0309             dict2.update(kwargs)
0310             kwargs=dict2
0311             self.__field_cmd=UINT(*args,**dict2)
0312         # Make all P fields that haven't already been constructed
0313 
0314 
0315     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0316         'Writes this packet to the supplied buffer'
0317         self._bufferstartoffset=buf.getcurrentoffset()
0318         self.__field_cmd.writetobuffer(buf)
0319         self._bufferendoffset=buf.getcurrentoffset()
0320         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0321 
0322 
0323     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0324         'Reads this packet from the supplied buffer'
0325         self._bufferstartoffset=buf.getcurrentoffset()
0326         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0327         self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x84})
0328         self.__field_cmd.readfrombuffer(buf)
0329         self._bufferendoffset=buf.getcurrentoffset()
0330 
0331 
0332     def __getfield_cmd(self):
0333         return self.__field_cmd.getvalue()
0334 
0335     def __setfield_cmd(self, value):
0336         if isinstance(value,UINT):
0337             self.__field_cmd=value
0338         else:
0339             self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'constant': 0x84})
0340 
0341     def __delfield_cmd(self): del self.__field_cmd
0342 
0343     cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None)
0344 
0345     def iscontainer(self):
0346         return True
0347 
0348     def containerelements(self):
0349         yield ('cmd', self.__field_cmd, None)
0350 
0351 
0352 
0353 
0354 class readpbentryrequest(BaseProtogenClass):
0355     __fields=['cmd', 'slotnumber']
0356 
0357     def __init__(self, *args, **kwargs):
0358         dict={}
0359         # What was supplied to this function
0360         dict.update(kwargs)
0361         # Parent constructor
0362         super(readpbentryrequest,self).__init__(**dict)
0363         if self.__class__ is readpbentryrequest:
0364             self._update(args,dict)
0365 
0366 
0367     def getfields(self):
0368         return self.__fields
0369 
0370 
0371     def _update(self, args, kwargs):
0372         super(readpbentryrequest,self)._update(args,kwargs)
0373         keys=kwargs.keys()
0374         for key in keys:
0375             if key in self.__fields:
0376                 setattr(self, key, kwargs[key])
0377                 del kwargs[key]
0378         # Were any unrecognized kwargs passed in?
0379         if __debug__:
0380             self._complainaboutunusedargs(readpbentryrequest,kwargs)
0381         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0382         # Make all P fields that haven't already been constructed
0383 
0384 
0385     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0386         'Writes this packet to the supplied buffer'
0387         self._bufferstartoffset=buf.getcurrentoffset()
0388         try: self.__field_cmd
0389         except:
0390             self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x83})
0391         self.__field_cmd.writetobuffer(buf)
0392         self.__field_slotnumber.writetobuffer(buf)
0393         self._bufferendoffset=buf.getcurrentoffset()
0394         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0395 
0396 
0397     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0398         'Reads this packet from the supplied buffer'
0399         self._bufferstartoffset=buf.getcurrentoffset()
0400         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0401         self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x83})
0402         self.__field_cmd.readfrombuffer(buf)
0403         self.__field_slotnumber=UINT(**{'sizeinbytes': 2})
0404         self.__field_slotnumber.readfrombuffer(buf)
0405         self._bufferendoffset=buf.getcurrentoffset()
0406 
0407 
0408     def __getfield_cmd(self):
0409         try: self.__field_cmd
0410         except:
0411             self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x83})
0412         return self.__field_cmd.getvalue()
0413 
0414     def __setfield_cmd(self, value):
0415         if isinstance(value,UINT):
0416             self.__field_cmd=value
0417         else:
0418             self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'constant': 0x83})
0419 
0420     def __delfield_cmd(self): del self.__field_cmd
0421 
0422     cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None)
0423 
0424     def __getfield_slotnumber(self):
0425         return self.__field_slotnumber.getvalue()
0426 
0427     def __setfield_slotnumber(self, value):
0428         if isinstance(value,UINT):
0429             self.__field_slotnumber=value
0430         else:
0431             self.__field_slotnumber=UINT(value,**{'sizeinbytes': 2})
0432 
0433     def __delfield_slotnumber(self): del self.__field_slotnumber
0434 
0435     slotnumber=property(__getfield_slotnumber, __setfield_slotnumber, __delfield_slotnumber, None)
0436 
0437     def iscontainer(self):
0438         return True
0439 
0440     def containerelements(self):
0441         yield ('cmd', self.__field_cmd, None)
0442         yield ('slotnumber', self.__field_slotnumber, None)
0443 
0444 
0445 
0446 
0447 class readpbentryresponse(BaseProtogenClass):
0448     __fields=['cmd', 'slotnumber', 'entry']
0449 
0450     def __init__(self, *args, **kwargs):
0451         dict={}
0452         # What was supplied to this function
0453         dict.update(kwargs)
0454         # Parent constructor
0455         super(readpbentryresponse,self).__init__(**dict)
0456         if self.__class__ is readpbentryresponse:
0457             self._update(args,dict)
0458 
0459 
0460     def getfields(self):
0461         return self.__fields
0462 
0463 
0464     def _update(self, args, kwargs):
0465         super(readpbentryresponse,self)._update(args,kwargs)
0466         keys=kwargs.keys()
0467         for key in keys:
0468             if key in self.__fields:
0469                 setattr(self, key, kwargs[key])
0470                 del kwargs[key]
0471         # Were any unrecognized kwargs passed in?
0472         if __debug__:
0473             self._complainaboutunusedargs(readpbentryresponse,kwargs)
0474         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0475         # Make all P fields that haven't already been constructed
0476 
0477 
0478     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0479         'Writes this packet to the supplied buffer'
0480         self._bufferstartoffset=buf.getcurrentoffset()
0481         try: self.__field_cmd
0482         except:
0483             self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x83})
0484         self.__field_cmd.writetobuffer(buf)
0485         self.__field_slotnumber.writetobuffer(buf)
0486         self.__field_entry.writetobuffer(buf)
0487         self._bufferendoffset=buf.getcurrentoffset()
0488         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0489 
0490 
0491     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0492         'Reads this packet from the supplied buffer'
0493         self._bufferstartoffset=buf.getcurrentoffset()
0494         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0495         self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x83})
0496         self.__field_cmd.readfrombuffer(buf)
0497         self.__field_slotnumber=UINT(**{'sizeinbytes': 2})
0498         self.__field_slotnumber.readfrombuffer(buf)
0499         self.__field_entry=pbentry()
0500         self.__field_entry.readfrombuffer(buf)
0501         self._bufferendoffset=buf.getcurrentoffset()
0502 
0503 
0504     def __getfield_cmd(self):
0505         try: self.__field_cmd
0506         except:
0507             self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x83})
0508         return self.__field_cmd.getvalue()
0509 
0510     def __setfield_cmd(self, value):
0511         if isinstance(value,UINT):
0512             self.__field_cmd=value
0513         else:
0514             self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'constant': 0x83})
0515 
0516     def __delfield_cmd(self): del self.__field_cmd
0517 
0518     cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None)
0519 
0520     def __getfield_slotnumber(self):
0521         return self.__field_slotnumber.getvalue()
0522 
0523     def __setfield_slotnumber(self, value):
0524         if isinstance(value,UINT):
0525             self.__field_slotnumber=value
0526         else:
0527             self.__field_slotnumber=UINT(value,**{'sizeinbytes': 2})
0528 
0529     def __delfield_slotnumber(self): del self.__field_slotnumber
0530 
0531     slotnumber=property(__getfield_slotnumber, __setfield_slotnumber, __delfield_slotnumber, None)
0532 
0533     def __getfield_entry(self):
0534         return self.__field_entry.getvalue()
0535 
0536     def __setfield_entry(self, value):
0537         if isinstance(value,pbentry):
0538             self.__field_entry=value
0539         else:
0540             self.__field_entry=pbentry(value,)
0541 
0542     def __delfield_entry(self): del self.__field_entry
0543 
0544     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
0545 
0546     def iscontainer(self):
0547         return True
0548 
0549     def containerelements(self):
0550         yield ('cmd', self.__field_cmd, None)
0551         yield ('slotnumber', self.__field_slotnumber, None)
0552         yield ('entry', self.__field_entry, None)
0553 
0554 
0555 
0556 
0557 class writepbentryrequest(BaseProtogenClass):
0558     __fields=['cmd', 'slotnumber', 'entry']
0559 
0560     def __init__(self, *args, **kwargs):
0561         dict={}
0562         # What was supplied to this function
0563         dict.update(kwargs)
0564         # Parent constructor
0565         super(writepbentryrequest,self).__init__(**dict)
0566         if self.__class__ is writepbentryrequest:
0567             self._update(args,dict)
0568 
0569 
0570     def getfields(self):
0571         return self.__fields
0572 
0573 
0574     def _update(self, args, kwargs):
0575         super(writepbentryrequest,self)._update(args,kwargs)
0576         keys=kwargs.keys()
0577         for key in keys:
0578             if key in self.__fields:
0579                 setattr(self, key, kwargs[key])
0580                 del kwargs[key]
0581         # Were any unrecognized kwargs passed in?
0582         if __debug__:
0583             self._complainaboutunusedargs(writepbentryrequest,kwargs)
0584         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0585         # Make all P fields that haven't already been constructed
0586 
0587 
0588     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0589         'Writes this packet to the supplied buffer'
0590         self._bufferstartoffset=buf.getcurrentoffset()
0591         try: self.__field_cmd
0592         except:
0593             self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x82})
0594         self.__field_cmd.writetobuffer(buf)
0595         self.__field_slotnumber.writetobuffer(buf)
0596         self.__field_entry.writetobuffer(buf)
0597         self._bufferendoffset=buf.getcurrentoffset()
0598         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0599 
0600 
0601     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0602         'Reads this packet from the supplied buffer'
0603         self._bufferstartoffset=buf.getcurrentoffset()
0604         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0605         self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x82})
0606         self.__field_cmd.readfrombuffer(buf)
0607         self.__field_slotnumber=UINT(**{'sizeinbytes': 2})
0608         self.__field_slotnumber.readfrombuffer(buf)
0609         self.__field_entry=pbentry()
0610         self.__field_entry.readfrombuffer(buf)
0611         self._bufferendoffset=buf.getcurrentoffset()
0612 
0613 
0614     def __getfield_cmd(self):
0615         try: self.__field_cmd
0616         except:
0617             self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x82})
0618         return self.__field_cmd.getvalue()
0619 
0620     def __setfield_cmd(self, value):
0621         if isinstance(value,UINT):
0622             self.__field_cmd=value
0623         else:
0624             self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'constant': 0x82})
0625 
0626     def __delfield_cmd(self): del self.__field_cmd
0627 
0628     cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None)
0629 
0630     def __getfield_slotnumber(self):
0631         return self.__field_slotnumber.getvalue()
0632 
0633     def __setfield_slotnumber(self, value):
0634         if isinstance(value,UINT):
0635             self.__field_slotnumber=value
0636         else:
0637             self.__field_slotnumber=UINT(value,**{'sizeinbytes': 2})
0638 
0639     def __delfield_slotnumber(self): del self.__field_slotnumber
0640 
0641     slotnumber=property(__getfield_slotnumber, __setfield_slotnumber, __delfield_slotnumber, None)
0642 
0643     def __getfield_entry(self):
0644         return self.__field_entry.getvalue()
0645 
0646     def __setfield_entry(self, value):
0647         if isinstance(value,pbentry):
0648             self.__field_entry=value
0649         else:
0650             self.__field_entry=pbentry(value,)
0651 
0652     def __delfield_entry(self): del self.__field_entry
0653 
0654     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
0655 
0656     def iscontainer(self):
0657         return True
0658 
0659     def containerelements(self):
0660         yield ('cmd', self.__field_cmd, None)
0661         yield ('slotnumber', self.__field_slotnumber, None)
0662         yield ('entry', self.__field_entry, None)
0663 
0664 
0665 
0666 
0667 class writepbentryresponse(BaseProtogenClass):
0668     __fields=['cmd', 'slotnumber']
0669 
0670     def __init__(self, *args, **kwargs):
0671         dict={}
0672         # What was supplied to this function
0673         dict.update(kwargs)
0674         # Parent constructor
0675         super(writepbentryresponse,self).__init__(**dict)
0676         if self.__class__ is writepbentryresponse:
0677             self._update(args,dict)
0678 
0679 
0680     def getfields(self):
0681         return self.__fields
0682 
0683 
0684     def _update(self, args, kwargs):
0685         super(writepbentryresponse,self)._update(args,kwargs)
0686         keys=kwargs.keys()
0687         for key in keys:
0688             if key in self.__fields:
0689                 setattr(self, key, kwargs[key])
0690                 del kwargs[key]
0691         # Were any unrecognized kwargs passed in?
0692         if __debug__:
0693             self._complainaboutunusedargs(writepbentryresponse,kwargs)
0694         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0695         # Make all P fields that haven't already been constructed
0696 
0697 
0698     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0699         'Writes this packet to the supplied buffer'
0700         self._bufferstartoffset=buf.getcurrentoffset()
0701         self.__field_cmd.writetobuffer(buf)
0702         self.__field_slotnumber.writetobuffer(buf)
0703         self._bufferendoffset=buf.getcurrentoffset()
0704         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0705 
0706 
0707     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0708         'Reads this packet from the supplied buffer'
0709         self._bufferstartoffset=buf.getcurrentoffset()
0710         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0711         self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x82})
0712         self.__field_cmd.readfrombuffer(buf)
0713         self.__field_slotnumber=UINT(**{'sizeinbytes': 2})
0714         self.__field_slotnumber.readfrombuffer(buf)
0715         self._bufferendoffset=buf.getcurrentoffset()
0716 
0717 
0718     def __getfield_cmd(self):
0719         return self.__field_cmd.getvalue()
0720 
0721     def __setfield_cmd(self, value):
0722         if isinstance(value,UINT):
0723             self.__field_cmd=value
0724         else:
0725             self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'constant': 0x82})
0726 
0727     def __delfield_cmd(self): del self.__field_cmd
0728 
0729     cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None)
0730 
0731     def __getfield_slotnumber(self):
0732         return self.__field_slotnumber.getvalue()
0733 
0734     def __setfield_slotnumber(self, value):
0735         if isinstance(value,UINT):
0736             self.__field_slotnumber=value
0737         else:
0738             self.__field_slotnumber=UINT(value,**{'sizeinbytes': 2})
0739 
0740     def __delfield_slotnumber(self): del self.__field_slotnumber
0741 
0742     slotnumber=property(__getfield_slotnumber, __setfield_slotnumber, __delfield_slotnumber, None)
0743 
0744     def iscontainer(self):
0745         return True
0746 
0747     def containerelements(self):
0748         yield ('cmd', self.__field_cmd, None)
0749         yield ('slotnumber', self.__field_slotnumber, None)
0750 
0751 
0752 
0753 
0754 class pbentry(BaseProtogenClass):
0755     __fields=['secret', 'group', 'previous', 'next', 'mobile', 'home', 'office', 'pager', 'fax', 'name', 'email', 'wireless', 'memo', 'ringtone', 'msgringtone', 'wallpaper']
0756 
0757     def __init__(self, *args, **kwargs):
0758         dict={}
0759         # What was supplied to this function
0760         dict.update(kwargs)
0761         # Parent constructor
0762         super(pbentry,self).__init__(**dict)
0763         if self.__class__ is pbentry:
0764             self._update(args,dict)
0765 
0766 
0767     def getfields(self):
0768         return self.__fields
0769 
0770 
0771     def _update(self, args, kwargs):
0772         super(pbentry,self)._update(args,kwargs)
0773         keys=kwargs.keys()
0774         for key in keys:
0775             if key in self.__fields:
0776                 setattr(self, key, kwargs[key])
0777                 del kwargs[key]
0778         # Were any unrecognized kwargs passed in?
0779         if __debug__:
0780             self._complainaboutunusedargs(pbentry,kwargs)
0781         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0782         # Make all P fields that haven't already been constructed
0783 
0784 
0785     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0786         'Writes this packet to the supplied buffer'
0787         self._bufferstartoffset=buf.getcurrentoffset()
0788         self.__field_secret.writetobuffer(buf)
0789         self.__field_group.writetobuffer(buf)
0790         self.__field_previous.writetobuffer(buf)
0791         self.__field_next.writetobuffer(buf)
0792         self.__field_mobile.writetobuffer(buf)
0793         self.__field_home.writetobuffer(buf)
0794         self.__field_office.writetobuffer(buf)
0795         self.__field_pager.writetobuffer(buf)
0796         self.__field_fax.writetobuffer(buf)
0797         self.__field_name.writetobuffer(buf)
0798         self.__field_email.writetobuffer(buf)
0799         self.__field_wireless.writetobuffer(buf)
0800         self.__field_memo.writetobuffer(buf)
0801         self.__field_ringtone.writetobuffer(buf)
0802         self.__field_msgringtone.writetobuffer(buf)
0803         self.__field_wallpaper.writetobuffer(buf)
0804         self._bufferendoffset=buf.getcurrentoffset()
0805         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0806 
0807 
0808     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0809         'Reads this packet from the supplied buffer'
0810         self._bufferstartoffset=buf.getcurrentoffset()
0811         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0812         self.__field_secret=UINT(**{'sizeinbytes': 1})
0813         self.__field_secret.readfrombuffer(buf)
0814         self.__field_group=UINT(**{'sizeinbytes': 1})
0815         self.__field_group.readfrombuffer(buf)
0816         self.__field_previous=UINT(**{'sizeinbytes': 2})
0817         self.__field_previous.readfrombuffer(buf)
0818         self.__field_next=UINT(**{'sizeinbytes': 2})
0819         self.__field_next.readfrombuffer(buf)
0820         self.__field_mobile=COUNTEDBUFFEREDSTRING(**{'sizeinbytes': 33})
0821         self.__field_mobile.readfrombuffer(buf)
0822         self.__field_home=COUNTEDBUFFEREDSTRING(**{'sizeinbytes': 33})
0823         self.__field_home.readfrombuffer(buf)
0824         self.__field_office=COUNTEDBUFFEREDSTRING(**{'sizeinbytes': 33})
0825         self.__field_office.readfrombuffer(buf)
0826         self.__field_pager=COUNTEDBUFFEREDSTRING(**{'sizeinbytes': 33})
0827         self.__field_pager.readfrombuffer(buf)
0828         self.__field_fax=COUNTEDBUFFEREDSTRING(**{'sizeinbytes': 33})
0829         self.__field_fax.readfrombuffer(buf)
0830         self.__field_name=USTRING(**{'sizeinbytes': 17})
0831         self.__field_name.readfrombuffer(buf)
0832         self.__field_email=USTRING(**{'sizeinbytes': 49})
0833         self.__field_email.readfrombuffer(buf)
0834         self.__field_wireless=USTRING(**{'sizeinbytes': 49})
0835         self.__field_wireless.readfrombuffer(buf)
0836         self.__field_memo=USTRING(**{'sizeinbytes': 49})
0837         self.__field_memo.readfrombuffer(buf)
0838         self.__field_ringtone=UINT(**{'sizeinbytes': 2})
0839         self.__field_ringtone.readfrombuffer(buf)
0840         self.__field_msgringtone=UINT(**{'sizeinbytes': 2})
0841         self.__field_msgringtone.readfrombuffer(buf)
0842         self.__field_wallpaper=UINT(**{'sizeinbytes': 2})
0843         self.__field_wallpaper.readfrombuffer(buf)
0844         self._bufferendoffset=buf.getcurrentoffset()
0845 
0846 
0847     def __getfield_secret(self):
0848         return self.__field_secret.getvalue()
0849 
0850     def __setfield_secret(self, value):
0851         if isinstance(value,UINT):
0852             self.__field_secret=value
0853         else:
0854             self.__field_secret=UINT(value,**{'sizeinbytes': 1})
0855 
0856     def __delfield_secret(self): del self.__field_secret
0857 
0858     secret=property(__getfield_secret, __setfield_secret, __delfield_secret, "non-zero if entry is secret/locked")
0859 
0860     def __getfield_group(self):
0861         return self.__field_group.getvalue()
0862 
0863     def __setfield_group(self, value):
0864         if isinstance(value,UINT):
0865             self.__field_group=value
0866         else:
0867             self.__field_group=UINT(value,**{'sizeinbytes': 1})
0868 
0869     def __delfield_group(self): del self.__field_group
0870 
0871     group=property(__getfield_group, __setfield_group, __delfield_group, None)
0872 
0873     def __getfield_previous(self):
0874         return self.__field_previous.getvalue()
0875 
0876     def __setfield_previous(self, value):
0877         if isinstance(value,UINT):
0878             self.__field_previous=value
0879         else:
0880             self.__field_previous=UINT(value,**{'sizeinbytes': 2})
0881 
0882     def __delfield_previous(self): del self.__field_previous
0883 
0884     previous=property(__getfield_previous, __setfield_previous, __delfield_previous, "?index number for previous entry")
0885 
0886     def __getfield_next(self):
0887         return self.__field_next.getvalue()
0888 
0889     def __setfield_next(self, value):
0890         if isinstance(value,UINT):
0891             self.__field_next=value
0892         else:
0893             self.__field_next=UINT(value,**{'sizeinbytes': 2})
0894 
0895     def __delfield_next(self): del self.__field_next
0896 
0897     next=property(__getfield_next, __setfield_next, __delfield_next, "?index number for next entry")
0898 
0899     def __getfield_mobile(self):
0900         return self.__field_mobile.getvalue()
0901 
0902     def __setfield_mobile(self, value):
0903         if isinstance(value,COUNTEDBUFFEREDSTRING):
0904             self.__field_mobile=value
0905         else:
0906             self.__field_mobile=COUNTEDBUFFEREDSTRING(value,**{'sizeinbytes': 33})
0907 
0908     def __delfield_mobile(self): del self.__field_mobile
0909 
0910     mobile=property(__getfield_mobile, __setfield_mobile, __delfield_mobile, None)
0911 
0912     def __getfield_home(self):
0913         return self.__field_home.getvalue()
0914 
0915     def __setfield_home(self, value):
0916         if isinstance(value,COUNTEDBUFFEREDSTRING):
0917             self.__field_home=value
0918         else:
0919             self.__field_home=COUNTEDBUFFEREDSTRING(value,**{'sizeinbytes': 33})
0920 
0921     def __delfield_home(self): del self.__field_home
0922 
0923     home=property(__getfield_home, __setfield_home, __delfield_home, None)
0924 
0925     def __getfield_office(self):
0926         return self.__field_office.getvalue()
0927 
0928     def __setfield_office(self, value):
0929         if isinstance(value,COUNTEDBUFFEREDSTRING):
0930             self.__field_office=value
0931         else:
0932             self.__field_office=COUNTEDBUFFEREDSTRING(value,**{'sizeinbytes': 33})
0933 
0934     def __delfield_office(self): del self.__field_office
0935 
0936     office=property(__getfield_office, __setfield_office, __delfield_office, None)
0937 
0938     def __getfield_pager(self):
0939         return self.__field_pager.getvalue()
0940 
0941     def __setfield_pager(self, value):
0942         if isinstance(value,COUNTEDBUFFEREDSTRING):
0943             self.__field_pager=value
0944         else:
0945             self.__field_pager=COUNTEDBUFFEREDSTRING(value,**{'sizeinbytes': 33})
0946 
0947     def __delfield_pager(self): del self.__field_pager
0948 
0949     pager=property(__getfield_pager, __setfield_pager, __delfield_pager, None)
0950 
0951     def __getfield_fax(self):
0952         return self.__field_fax.getvalue()
0953 
0954     def __setfield_fax(self, value):
0955         if isinstance(value,COUNTEDBUFFEREDSTRING):
0956             self.__field_fax=value
0957         else:
0958             self.__field_fax=COUNTEDBUFFEREDSTRING(value,**{'sizeinbytes': 33})
0959 
0960     def __delfield_fax(self): del self.__field_fax
0961 
0962     fax=property(__getfield_fax, __setfield_fax, __delfield_fax, None)
0963 
0964     def __getfield_name(self):
0965         return self.__field_name.getvalue()
0966 
0967     def __setfield_name(self, value):
0968         if isinstance(value,USTRING):
0969             self.__field_name=value
0970         else:
0971             self.__field_name=USTRING(value,**{'sizeinbytes': 17})
0972 
0973     def __delfield_name(self): del self.__field_name
0974 
0975     name=property(__getfield_name, __setfield_name, __delfield_name, None)
0976 
0977     def __getfield_email(self):
0978         return self.__field_email.getvalue()
0979 
0980     def __setfield_email(self, value):
0981         if isinstance(value,USTRING):
0982             self.__field_email=value
0983         else:
0984             self.__field_email=USTRING(value,**{'sizeinbytes': 49})
0985 
0986     def __delfield_email(self): del self.__field_email
0987 
0988     email=property(__getfield_email, __setfield_email, __delfield_email, None)
0989 
0990     def __getfield_wireless(self):
0991         return self.__field_wireless.getvalue()
0992 
0993     def __setfield_wireless(self, value):
0994         if isinstance(value,USTRING):
0995             self.__field_wireless=value
0996         else:
0997             self.__field_wireless=USTRING(value,**{'sizeinbytes': 49})
0998 
0999     def __delfield_wireless(self): del self.__field_wireless
1000 
1001     wireless=property(__getfield_wireless, __setfield_wireless, __delfield_wireless, None)
1002 
1003     def __getfield_memo(self):
1004         return self.__field_memo.getvalue()
1005 
1006     def __setfield_memo(self, value):
1007         if isinstance(value,USTRING):
1008             self.__field_memo=value
1009         else:
1010             self.__field_memo=USTRING(value,**{'sizeinbytes': 49})
1011 
1012     def __delfield_memo(self): del self.__field_memo
1013 
1014     memo=property(__getfield_memo, __setfield_memo, __delfield_memo, None)
1015 
1016     def __getfield_ringtone(self):
1017         return self.__field_ringtone.getvalue()
1018 
1019     def __setfield_ringtone(self, value):
1020         if isinstance(value,UINT):
1021             self.__field_ringtone=value
1022         else:
1023             self.__field_ringtone=UINT(value,**{'sizeinbytes': 2})
1024 
1025     def __delfield_ringtone(self): del self.__field_ringtone
1026 
1027     ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None)
1028 
1029     def __getfield_msgringtone(self):
1030         return self.__field_msgringtone.getvalue()
1031 
1032     def __setfield_msgringtone(self, value):
1033         if isinstance(value,UINT):
1034             self.__field_msgringtone=value
1035         else:
1036             self.__field_msgringtone=UINT(value,**{'sizeinbytes': 2})
1037 
1038     def __delfield_msgringtone(self): del self.__field_msgringtone
1039 
1040     msgringtone=property(__getfield_msgringtone, __setfield_msgringtone, __delfield_msgringtone, None)
1041 
1042     def __getfield_wallpaper(self):
1043         return self.__field_wallpaper.getvalue()
1044 
1045     def __setfield_wallpaper(self, value):
1046         if isinstance(value,UINT):
1047             self.__field_wallpaper=value
1048         else:
1049             self.__field_wallpaper=UINT(value,**{'sizeinbytes': 2})
1050 
1051     def __delfield_wallpaper(self): del self.__field_wallpaper
1052 
1053     wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None)
1054 
1055     def iscontainer(self):
1056         return True
1057 
1058     def containerelements(self):
1059         yield ('secret', self.__field_secret, "non-zero if entry is secret/locked")
1060         yield ('group', self.__field_group, None)
1061         yield ('previous', self.__field_previous, "?index number for previous entry")
1062         yield ('next', self.__field_next, "?index number for next entry")
1063         yield ('mobile', self.__field_mobile, None)
1064         yield ('home', self.__field_home, None)
1065         yield ('office', self.__field_office, None)
1066         yield ('pager', self.__field_pager, None)
1067         yield ('fax', self.__field_fax, None)
1068         yield ('name', self.__field_name, None)
1069         yield ('email', self.__field_email, None)
1070         yield ('wireless', self.__field_wireless, None)
1071         yield ('memo', self.__field_memo, None)
1072         yield ('ringtone', self.__field_ringtone, None)
1073         yield ('msgringtone', self.__field_msgringtone, None)
1074         yield ('wallpaper', self.__field_wallpaper, None)
1075 
1076 
1077 
1078 
1079 class readgroupentryrequest(BaseProtogenClass):
1080     __fields=['cmd', 'number']
1081 
1082     def __init__(self, *args, **kwargs):
1083         dict={}
1084         # What was supplied to this function
1085         dict.update(kwargs)
1086         # Parent constructor
1087         super(readgroupentryrequest,self).__init__(**dict)
1088         if self.__class__ is readgroupentryrequest:
1089             self._update(args,dict)
1090 
1091 
1092     def getfields(self):
1093         return self.__fields
1094 
1095 
1096     def _update(self, args, kwargs):
1097         super(readgroupentryrequest,self)._update(args,kwargs)
1098         keys=kwargs.keys()
1099         for key in keys:
1100             if key in self.__fields:
1101                 setattr(self, key, kwargs[key])
1102                 del kwargs[key]
1103         # Were any unrecognized kwargs passed in?
1104         if __debug__:
1105             self._complainaboutunusedargs(readgroupentryrequest,kwargs)
1106         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1107         # Make all P fields that haven't already been constructed
1108 
1109 
1110     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1111         'Writes this packet to the supplied buffer'
1112         self._bufferstartoffset=buf.getcurrentoffset()
1113         try: self.__field_cmd
1114         except:
1115             self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x81})
1116         self.__field_cmd.writetobuffer(buf)
1117         self.__field_number.writetobuffer(buf)
1118         self._bufferendoffset=buf.getcurrentoffset()
1119         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1120 
1121 
1122     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1123         'Reads this packet from the supplied buffer'
1124         self._bufferstartoffset=buf.getcurrentoffset()
1125         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1126         self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x81})
1127         self.__field_cmd.readfrombuffer(buf)
1128         self.__field_number=UINT(**{'sizeinbytes': 1})
1129         self.__field_number.readfrombuffer(buf)
1130         self._bufferendoffset=buf.getcurrentoffset()
1131 
1132 
1133     def __getfield_cmd(self):
1134         try: self.__field_cmd
1135         except:
1136             self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x81})
1137         return self.__field_cmd.getvalue()
1138 
1139     def __setfield_cmd(self, value):
1140         if isinstance(value,UINT):
1141             self.__field_cmd=value
1142         else:
1143             self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'constant': 0x81})
1144 
1145     def __delfield_cmd(self): del self.__field_cmd
1146 
1147     cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None)
1148 
1149     def __getfield_number(self):
1150         return self.__field_number.getvalue()
1151 
1152     def __setfield_number(self, value):
1153         if isinstance(value,UINT):
1154             self.__field_number=value
1155         else:
1156             self.__field_number=UINT(value,**{'sizeinbytes': 1})
1157 
1158     def __delfield_number(self): del self.__field_number
1159 
1160     number=property(__getfield_number, __setfield_number, __delfield_number, None)
1161 
1162     def iscontainer(self):
1163         return True
1164 
1165     def containerelements(self):
1166         yield ('cmd', self.__field_cmd, None)
1167         yield ('number', self.__field_number, None)
1168 
1169 
1170 
1171 
1172 class readgroupentryresponse(BaseProtogenClass):
1173     __fields=['cmd', 'number', 'anothergroupnum', 'dunno', 'name', 'nummembers']
1174 
1175     def __init__(self, *args, **kwargs):
1176         dict={}
1177         # What was supplied to this function
1178         dict.update(kwargs)
1179         # Parent constructor
1180         super(readgroupentryresponse,self).__init__(**dict)
1181         if self.__class__ is readgroupentryresponse:
1182             self._update(args,dict)
1183 
1184 
1185     def getfields(self):
1186         return self.__fields
1187 
1188 
1189     def _update(self, args, kwargs):
1190         super(readgroupentryresponse,self)._update(args,kwargs)
1191         keys=kwargs.keys()
1192         for key in keys:
1193             if key in self.__fields:
1194                 setattr(self, key, kwargs[key])
1195                 del kwargs[key]
1196         # Were any unrecognized kwargs passed in?
1197         if __debug__:
1198             self._complainaboutunusedargs(readgroupentryresponse,kwargs)
1199         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1200         # Make all P fields that haven't already been constructed
1201 
1202 
1203     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1204         'Writes this packet to the supplied buffer'
1205         self._bufferstartoffset=buf.getcurrentoffset()
1206         self.__field_cmd.writetobuffer(buf)
1207         self.__field_number.writetobuffer(buf)
1208         self.__field_anothergroupnum.writetobuffer(buf)
1209         self.__field_dunno.writetobuffer(buf)
1210         self.__field_name.writetobuffer(buf)
1211         self.__field_nummembers.writetobuffer(buf)
1212         self._bufferendoffset=buf.getcurrentoffset()
1213         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1214 
1215 
1216     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1217         'Reads this packet from the supplied buffer'
1218         self._bufferstartoffset=buf.getcurrentoffset()
1219         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1220         self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x81})
1221         self.__field_cmd.readfrombuffer(buf)
1222         self.__field_number=UINT(**{'sizeinbytes': 1})
1223         self.__field_number.readfrombuffer(buf)
1224         self.__field_anothergroupnum=UINT(**{'sizeinbytes': 1})
1225         self.__field_anothergroupnum.readfrombuffer(buf)
1226         self.__field_dunno=UINT(**{'sizeinbytes': 2})
1227         self.__field_dunno.readfrombuffer(buf)
1228         self.__field_name=USTRING(**{'sizeinbytes': 17})
1229         self.__field_name.readfrombuffer(buf)
1230         self.__field_nummembers=UINT(**{'sizeinbytes': 2})
1231         self.__field_nummembers.readfrombuffer(buf)
1232         self._bufferendoffset=buf.getcurrentoffset()
1233 
1234 
1235     def __getfield_cmd(self):
1236         return self.__field_cmd.getvalue()
1237 
1238     def __setfield_cmd(self, value):
1239         if isinstance(value,UINT):
1240             self.__field_cmd=value
1241         else:
1242             self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'constant': 0x81})
1243 
1244     def __delfield_cmd(self): del self.__field_cmd
1245 
1246     cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None)
1247 
1248     def __getfield_number(self):
1249         return self.__field_number.getvalue()
1250 
1251     def __setfield_number(self, value):
1252         if isinstance(value,UINT):
1253             self.__field_number=value
1254         else:
1255             self.__field_number=UINT(value,**{'sizeinbytes': 1})
1256 
1257     def __delfield_number(self): del self.__field_number
1258 
1259     number=property(__getfield_number, __setfield_number, __delfield_number, None)
1260 
1261     def __getfield_anothergroupnum(self):
1262         return self.__field_anothergroupnum.getvalue()
1263 
1264     def __setfield_anothergroupnum(self, value):
1265         if isinstance(value,UINT):
1266             self.__field_anothergroupnum=value
1267         else:
1268             self.__field_anothergroupnum=UINT(value,**{'sizeinbytes': 1})
1269 
1270     def __delfield_anothergroupnum(self): del self.__field_anothergroupnum
1271 
1272     anothergroupnum=property(__getfield_anothergroupnum, __setfield_anothergroupnum, __delfield_anothergroupnum, None)
1273 
1274     def __getfield_dunno(self):
1275         return self.__field_dunno.getvalue()
1276 
1277     def __setfield_dunno(self, value):
1278         if isinstance(value,UINT):
1279             self.__field_dunno=value
1280         else:
1281             self.__field_dunno=UINT(value,**{'sizeinbytes': 2})
1282 
1283     def __delfield_dunno(self): del self.__field_dunno
1284 
1285     dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, "first member?")
1286 
1287     def __getfield_name(self):
1288         return self.__field_name.getvalue()
1289 
1290     def __setfield_name(self, value):
1291         if isinstance(value,USTRING):
1292             self.__field_name=value
1293         else:
1294             self.__field_name=USTRING(value,**{'sizeinbytes': 17})
1295 
1296     def __delfield_name(self): del self.__field_name
1297 
1298     name=property(__getfield_name, __setfield_name, __delfield_name, None)
1299 
1300     def __getfield_nummembers(self):
1301         return self.__field_nummembers.getvalue()
1302 
1303     def __setfield_nummembers(self, value):
1304         if isinstance(value,UINT):
1305             self.__field_nummembers=value
1306         else:
1307             self.__field_nummembers=UINT(value,**{'sizeinbytes': 2})
1308 
1309     def __delfield_nummembers(self): del self.__field_nummembers
1310 
1311     nummembers=property(__getfield_nummembers, __setfield_nummembers, __delfield_nummembers, "how many members of the group")
1312 
1313     def iscontainer(self):
1314         return True
1315 
1316     def containerelements(self):
1317         yield ('cmd', self.__field_cmd, None)
1318         yield ('number', self.__field_number, None)
1319         yield ('anothergroupnum', self.__field_anothergroupnum, None)
1320         yield ('dunno', self.__field_dunno, "first member?")
1321         yield ('name', self.__field_name, None)
1322         yield ('nummembers', self.__field_nummembers, "how many members of the group")
1323 
1324 
1325 
1326 
1327 class writegroupentryrequest(BaseProtogenClass):
1328     __fields=['cmd', 'number', 'anothernumber', 'dunno', 'name', 'nummembers']
1329 
1330     def __init__(self, *args, **kwargs):
1331         dict={}
1332         # What was supplied to this function
1333         dict.update(kwargs)
1334         # Parent constructor
1335         super(writegroupentryrequest,self).__init__(**dict)
1336         if self.__class__ is writegroupentryrequest:
1337             self._update(args,dict)
1338 
1339 
1340     def getfields(self):
1341         return self.__fields
1342 
1343 
1344     def _update(self, args, kwargs):
1345         super(writegroupentryrequest,self)._update(args,kwargs)
1346         keys=kwargs.keys()
1347         for key in keys:
1348             if key in self.__fields:
1349                 setattr(self, key, kwargs[key])
1350                 del kwargs[key]
1351         # Were any unrecognized kwargs passed in?
1352         if __debug__:
1353             self._complainaboutunusedargs(writegroupentryrequest,kwargs)
1354         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1355         # Make all P fields that haven't already been constructed
1356 
1357 
1358     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1359         'Writes this packet to the supplied buffer'
1360         self._bufferstartoffset=buf.getcurrentoffset()
1361         try: self.__field_cmd
1362         except:
1363             self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x80})
1364         self.__field_cmd.writetobuffer(buf)
1365         self.__field_number.writetobuffer(buf)
1366         self.__field_anothernumber.writetobuffer(buf)
1367         try: self.__field_dunno
1368         except:
1369             self.__field_dunno=UINT(**{'sizeinbytes': 2, 'constant': 0xffff})
1370         self.__field_dunno.writetobuffer(buf)
1371         self.__field_name.writetobuffer(buf)
1372         self.__field_nummembers.writetobuffer(buf)
1373         self._bufferendoffset=buf.getcurrentoffset()
1374         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1375 
1376 
1377     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1378         'Reads this packet from the supplied buffer'
1379         self._bufferstartoffset=buf.getcurrentoffset()
1380         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1381         self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x80})
1382         self.__field_cmd.readfrombuffer(buf)
1383         self.__field_number=UINT(**{'sizeinbytes': 1})
1384         self.__field_number.readfrombuffer(buf)
1385         self.__field_anothernumber=UINT(**{'sizeinbytes': 1})
1386         self.__field_anothernumber.readfrombuffer(buf)
1387         self.__field_dunno=UINT(**{'sizeinbytes': 2, 'constant': 0xffff})
1388         self.__field_dunno.readfrombuffer(buf)
1389         self.__field_name=USTRING(**{'sizeinbytes': 17})
1390         self.__field_name.readfrombuffer(buf)
1391         self.__field_nummembers=UINT(**{'sizeinbytes': 2})
1392         self.__field_nummembers.readfrombuffer(buf)
1393         self._bufferendoffset=buf.getcurrentoffset()
1394 
1395 
1396     def __getfield_cmd(self):
1397         try: self.__field_cmd
1398         except:
1399             self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x80})
1400         return self.__field_cmd.getvalue()
1401 
1402     def __setfield_cmd(self, value):
1403         if isinstance(value,UINT):
1404             self.__field_cmd=value
1405         else:
1406             self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'constant': 0x80})
1407 
1408     def __delfield_cmd(self): del self.__field_cmd
1409 
1410     cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None)
1411 
1412     def __getfield_number(self):
1413         return self.__field_number.getvalue()
1414 
1415     def __setfield_number(self, value):
1416         if isinstance(value,UINT):
1417             self.__field_number=value
1418         else:
1419             self.__field_number=UINT(value,**{'sizeinbytes': 1})
1420 
1421     def __delfield_number(self): del self.__field_number
1422 
1423     number=property(__getfield_number, __setfield_number, __delfield_number, None)
1424 
1425     def __getfield_anothernumber(self):
1426         return self.__field_anothernumber.getvalue()
1427 
1428     def __setfield_anothernumber(self, value):
1429         if isinstance(value,UINT):
1430             self.__field_anothernumber=value
1431         else:
1432             self.__field_anothernumber=UINT(value,**{'sizeinbytes': 1})
1433 
1434     def __delfield_anothernumber(self): del self.__field_anothernumber
1435 
1436     anothernumber=property(__getfield_anothernumber, __setfield_anothernumber, __delfield_anothernumber, "same as number")
1437 
1438     def __getfield_dunno(self):
1439         try: self.__field_dunno
1440         except:
1441             self.__field_dunno=UINT(**{'sizeinbytes': 2, 'constant': 0xffff})
1442         return self.__field_dunno.getvalue()
1443 
1444     def __setfield_dunno(self, value):
1445         if isinstance(value,UINT):
1446             self.__field_dunno=value
1447         else:
1448             self.__field_dunno=UINT(value,**{'sizeinbytes': 2, 'constant': 0xffff})
1449 
1450     def __delfield_dunno(self): del self.__field_dunno
1451 
1452     dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, "?first member of the group")
1453 
1454     def __getfield_name(self):
1455         return self.__field_name.getvalue()
1456 
1457     def __setfield_name(self, value):
1458         if isinstance(value,USTRING):
1459             self.__field_name=value
1460         else:
1461             self.__field_name=USTRING(value,**{'sizeinbytes': 17})
1462 
1463     def __delfield_name(self): del self.__field_name
1464 
1465     name=property(__getfield_name, __setfield_name, __delfield_name, None)
1466 
1467     def __getfield_nummembers(self):
1468         return self.__field_nummembers.getvalue()
1469 
1470     def __setfield_nummembers(self, value):
1471         if isinstance(value,UINT):
1472             self.__field_nummembers=value
1473         else:
1474             self.__field_nummembers=UINT(value,**{'sizeinbytes': 2})
1475 
1476     def __delfield_nummembers(self): del self.__field_nummembers
1477 
1478     nummembers=property(__getfield_nummembers, __setfield_nummembers, __delfield_nummembers, None)
1479 
1480     def iscontainer(self):
1481         return True
1482 
1483     def containerelements(self):
1484         yield ('cmd', self.__field_cmd, None)
1485         yield ('number', self.__field_number, None)
1486         yield ('anothernumber', self.__field_anothernumber, "same as number")
1487         yield ('dunno', self.__field_dunno, "?first member of the group")
1488         yield ('name', self.__field_name, None)
1489         yield ('nummembers', self.__field_nummembers, None)
1490 
1491 
1492 
1493 
1494 class writegroupentryresponse(BaseProtogenClass):
1495     __fields=['cmd']
1496 
1497     def __init__(self, *args, **kwargs):
1498         dict={}
1499         # What was supplied to this function
1500         dict.update(kwargs)
1501         # Parent constructor
1502         super(writegroupentryresponse,self).__init__(**dict)
1503         if self.__class__ is writegroupentryresponse:
1504             self._update(args,dict)
1505 
1506 
1507     def getfields(self):
1508         return self.__fields
1509 
1510 
1511     def _update(self, args, kwargs):
1512         super(writegroupentryresponse,self)._update(args,kwargs)
1513         keys=kwargs.keys()
1514         for key in keys:
1515             if key in self.__fields:
1516                 setattr(self, key, kwargs[key])
1517                 del kwargs[key]
1518         # Were any unrecognized kwargs passed in?
1519         if __debug__:
1520             self._complainaboutunusedargs(writegroupentryresponse,kwargs)
1521         if len(args):
1522             dict2={'sizeinbytes': 1, 'constant': 0x80}
1523             dict2.update(kwargs)
1524             kwargs=dict2
1525             self.__field_cmd=UINT(*args,**dict2)
1526         # Make all P fields that haven't already been constructed
1527 
1528 
1529     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1530         'Writes this packet to the supplied buffer'
1531         self._bufferstartoffset=buf.getcurrentoffset()
1532         self.__field_cmd.writetobuffer(buf)
1533         self._bufferendoffset=buf.getcurrentoffset()
1534         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1535 
1536 
1537     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1538         'Reads this packet from the supplied buffer'
1539         self._bufferstartoffset=buf.getcurrentoffset()
1540         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1541         self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x80})
1542         self.__field_cmd.readfrombuffer(buf)
1543         self._bufferendoffset=buf.getcurrentoffset()
1544 
1545 
1546     def __getfield_cmd(self):
1547         return self.__field_cmd.getvalue()
1548 
1549     def __setfield_cmd(self, value):
1550         if isinstance(value,UINT):
1551             self.__field_cmd=value
1552         else:
1553             self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'constant': 0x80})
1554 
1555     def __delfield_cmd(self): del self.__field_cmd
1556 
1557     cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None)
1558 
1559     def iscontainer(self):
1560         return True
1561 
1562     def containerelements(self):
1563         yield ('cmd', self.__field_cmd, None)
1564 
1565 
1566 
1567 
1568 class dunnorequest(BaseProtogenClass):
1569     __fields=['cmd', 'cmd2', 'cmd3', 'which']
1570 
1571     def __init__(self, *args, **kwargs):
1572         dict={}
1573         # What was supplied to this function
1574         dict.update(kwargs)
1575         # Parent constructor
1576         super(dunnorequest,self).__init__(**dict)
1577         if self.__class__ is dunnorequest:
1578             self._update(args,dict)
1579 
1580 
1581     def getfields(self):
1582         return self.__fields
1583 
1584 
1585     def _update(self, args, kwargs):
1586         super(dunnorequest,self)._update(args,kwargs)
1587         keys=kwargs.keys()
1588         for key in keys:
1589             if key in self.__fields:
1590                 setattr(self, key, kwargs[key])
1591                 del kwargs[key]
1592         # Were any unrecognized kwargs passed in?
1593         if __debug__:
1594             self._complainaboutunusedargs(dunnorequest,kwargs)
1595         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1596         # Make all P fields that haven't already been constructed
1597 
1598 
1599     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1600         'Writes this packet to the supplied buffer'
1601         self._bufferstartoffset=buf.getcurrentoffset()
1602         try: self.__field_cmd
1603         except:
1604             self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x26})
1605         self.__field_cmd.writetobuffer(buf)
1606         try: self.__field_cmd2
1607         except:
1608             self.__field_cmd2=UINT(**{'sizeinbytes': 1, 'constant': 0xf7})
1609         self.__field_cmd2.writetobuffer(buf)
1610         try: self.__field_cmd3
1611         except:
1612             self.__field_cmd3=UINT(**{'sizeinbytes': 1, 'constant': 0x03})
1613         self.__field_cmd3.writetobuffer(buf)
1614         self.__field_which.writetobuffer(buf)
1615         self._bufferendoffset=buf.getcurrentoffset()
1616         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1617 
1618 
1619     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1620         'Reads this packet from the supplied buffer'
1621         self._bufferstartoffset=buf.getcurrentoffset()
1622         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1623         self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x26})
1624         self.__field_cmd.readfrombuffer(buf)
1625         self.__field_cmd2=UINT(**{'sizeinbytes': 1, 'constant': 0xf7})
1626         self.__field_cmd2.readfrombuffer(buf)
1627         self.__field_cmd3=UINT(**{'sizeinbytes': 1, 'constant': 0x03})
1628         self.__field_cmd3.readfrombuffer(buf)
1629         self.__field_which=UINT(**{'sizeinbytes': 1})
1630         self.__field_which.readfrombuffer(buf)
1631         self._bufferendoffset=buf.getcurrentoffset()
1632 
1633 
1634     def __getfield_cmd(self):
1635         try: self.__field_cmd
1636         except:
1637             self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x26})
1638         return self.__field_cmd.getvalue()
1639 
1640     def __setfield_cmd(self, value):
1641         if isinstance(value,UINT):
1642             self.__field_cmd=value
1643         else:
1644             self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'constant': 0x26})
1645 
1646     def __delfield_cmd(self): del self.__field_cmd
1647 
1648     cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None)
1649 
1650     def __getfield_cmd2(self):
1651         try: self.__field_cmd2
1652         except:
1653             self.__field_cmd2=UINT(**{'sizeinbytes': 1, 'constant': 0xf7})
1654         return self.__field_cmd2.getvalue()
1655 
1656     def __setfield_cmd2(self, value):
1657         if isinstance(value,UINT):
1658             self.__field_cmd2=value
1659         else:
1660             self.__field_cmd2=UINT(value,**{'sizeinbytes': 1, 'constant': 0xf7})
1661 
1662     def __delfield_cmd2(self): del self.__field_cmd2
1663 
1664     cmd2=property(__getfield_cmd2, __setfield_cmd2, __delfield_cmd2, None)
1665 
1666     def __getfield_cmd3(self):
1667         try: self.__field_cmd3
1668         except:
1669             self.__field_cmd3=UINT(**{'sizeinbytes': 1, 'constant': 0x03})
1670         return self.__field_cmd3.getvalue()
1671 
1672     def __setfield_cmd3(self, value):
1673         if isinstance(value,UINT):
1674             self.__field_cmd3=value
1675         else:
1676             self.__field_cmd3=UINT(value,**{'sizeinbytes': 1, 'constant': 0x03})
1677 
1678     def __delfield_cmd3(self): del self.__field_cmd3
1679 
1680     cmd3=property(__getfield_cmd3, __setfield_cmd3, __delfield_cmd3, None)
1681 
1682     def __getfield_which(self):
1683         return self.__field_which.getvalue()
1684 
1685     def __setfield_which(self, value):
1686         if isinstance(value,UINT):
1687             self.__field_which=value
1688         else:
1689             self.__field_which=UINT(value,**{'sizeinbytes': 1})
1690 
1691     def __delfield_which(self): del self.__field_which
1692 
1693     which=property(__getfield_which, __setfield_which, __delfield_which, None)
1694 
1695     def iscontainer(self):
1696         return True
1697 
1698     def containerelements(self):
1699         yield ('cmd', self.__field_cmd, None)
1700         yield ('cmd2', self.__field_cmd2, None)
1701         yield ('cmd3', self.__field_cmd3, None)
1702         yield ('which', self.__field_which, None)
1703 
1704 
1705 
1706 
1707 class dunnoresponse(BaseProtogenClass):
1708     __fields=['stuff']
1709 
1710     def __init__(self, *args, **kwargs):
1711         dict={}
1712         # What was supplied to this function
1713         dict.update(kwargs)
1714         # Parent constructor
1715         super(dunnoresponse,self).__init__(**dict)
1716         if self.__class__ is dunnoresponse:
1717             self._update(args,dict)
1718 
1719 
1720     def getfields(self):
1721         return self.__fields
1722 
1723 
1724     def _update(self, args, kwargs):
1725         super(dunnoresponse,self)._update(args,kwargs)
1726         keys=kwargs.keys()
1727         for key in keys:
1728             if key in self.__fields:
1729                 setattr(self, key, kwargs[key])
1730                 del kwargs[key]
1731         # Were any unrecognized kwargs passed in?
1732         if __debug__:
1733             self._complainaboutunusedargs(dunnoresponse,kwargs)
1734         if len(args):
1735             dict2={}
1736             dict2.update(kwargs)
1737             kwargs=dict2
1738             self.__field_stuff=DATA(*args,**dict2)
1739         # Make all P fields that haven't already been constructed
1740 
1741 
1742     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1743         'Writes this packet to the supplied buffer'
1744         self._bufferstartoffset=buf.getcurrentoffset()
1745         self.__field_stuff.writetobuffer(buf)
1746         self._bufferendoffset=buf.getcurrentoffset()
1747         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1748 
1749 
1750     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1751         'Reads this packet from the supplied buffer'
1752         self._bufferstartoffset=buf.getcurrentoffset()
1753         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1754         self.__field_stuff=DATA()
1755         self.__field_stuff.readfrombuffer(buf)
1756         self._bufferendoffset=buf.getcurrentoffset()
1757 
1758 
1759     def __getfield_stuff(self):
1760         return self.__field_stuff.getvalue()
1761 
1762     def __setfield_stuff(self, value):
1763         if isinstance(value,DATA):
1764             self.__field_stuff=value
1765         else:
1766             self.__field_stuff=DATA(value,)
1767 
1768     def __delfield_stuff(self): del self.__field_stuff
1769 
1770     stuff=property(__getfield_stuff, __setfield_stuff, __delfield_stuff, None)
1771 
1772     def iscontainer(self):
1773         return True
1774 
1775     def containerelements(self):
1776         yield ('stuff', self.__field_stuff, None)
1777 
1778 
1779 
1780 
1781 class readlockcoderequest(BaseProtogenClass):
1782     __fields=['cmd', 'cmd2', 'cmd3', 'padding']
1783 
1784     def __init__(self, *args, **kwargs):
1785         dict={}
1786         # What was supplied to this function
1787         dict.update(kwargs)
1788         # Parent constructor
1789         super(readlockcoderequest,self).__init__(**dict)
1790         if self.__class__ is readlockcoderequest:
1791             self._update(args,dict)
1792 
1793 
1794     def getfields(self):
1795         return self.__fields
1796 
1797 
1798     def _update(self, args, kwargs):
1799         super(readlockcoderequest,self)._update(args,kwargs)
1800         keys=kwargs.keys()
1801         for key in keys:
1802             if key in self.__fields:
1803                 setattr(self, key, kwargs[key])
1804                 del kwargs[key]
1805         # Were any unrecognized kwargs passed in?
1806         if __debug__:
1807             self._complainaboutunusedargs(readlockcoderequest,kwargs)
1808         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1809         # Make all P fields that haven't already been constructed
1810 
1811 
1812     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1813         'Writes this packet to the supplied buffer'
1814         self._bufferstartoffset=buf.getcurrentoffset()
1815         try: self.__field_cmd
1816         except:
1817             self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x26})
1818         self.__field_cmd.writetobuffer(buf)
1819         try: self.__field_cmd2
1820         except:
1821             self.__field_cmd2=UINT(**{'sizeinbytes': 1, 'constant': 0x52})
1822         self.__field_cmd2.writetobuffer(buf)
1823         try: self.__field_cmd3
1824         except:
1825             self.__field_cmd3=UINT(**{'sizeinbytes': 1, 'constant': 0x00})
1826         self.__field_cmd3.writetobuffer(buf)
1827         try: self.__field_padding
1828         except:
1829             self.__field_padding=DATA(**{'sizeinbytes': 130})
1830         self.__field_padding.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_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x26})
1840         self.__field_cmd.readfrombuffer(buf)
1841         self.__field_cmd2=UINT(**{'sizeinbytes': 1, 'constant': 0x52})
1842         self.__field_cmd2.readfrombuffer(buf)
1843         self.__field_cmd3=UINT(**{'sizeinbytes': 1, 'constant': 0x00})
1844         self.__field_cmd3.readfrombuffer(buf)
1845         self.__field_padding=DATA(**{'sizeinbytes': 130})
1846         self.__field_padding.readfrombuffer(buf)
1847         self._bufferendoffset=buf.getcurrentoffset()
1848 
1849 
1850     def __getfield_cmd(self):
1851         try: self.__field_cmd
1852         except:
1853             self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x26})
1854         return self.__field_cmd.getvalue()
1855 
1856     def __setfield_cmd(self, value):
1857         if isinstance(value,UINT):
1858             self.__field_cmd=value
1859         else:
1860             self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'constant': 0x26})
1861 
1862     def __delfield_cmd(self): del self.__field_cmd
1863 
1864     cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None)
1865 
1866     def __getfield_cmd2(self):
1867         try: self.__field_cmd2
1868         except:
1869             self.__field_cmd2=UINT(**{'sizeinbytes': 1, 'constant': 0x52})
1870         return self.__field_cmd2.getvalue()
1871 
1872     def __setfield_cmd2(self, value):
1873         if isinstance(value,UINT):
1874             self.__field_cmd2=value
1875         else:
1876             self.__field_cmd2=UINT(value,**{'sizeinbytes': 1, 'constant': 0x52})
1877 
1878     def __delfield_cmd2(self): del self.__field_cmd2
1879 
1880     cmd2=property(__getfield_cmd2, __setfield_cmd2, __delfield_cmd2, None)
1881 
1882     def __getfield_cmd3(self):
1883         try: self.__field_cmd3
1884         except:
1885             self.__field_cmd3=UINT(**{'sizeinbytes': 1, 'constant': 0x00})
1886         return self.__field_cmd3.getvalue()
1887 
1888     def __setfield_cmd3(self, value):
1889         if isinstance(value,UINT):
1890             self.__field_cmd3=value
1891         else:
1892             self.__field_cmd3=UINT(value,**{'sizeinbytes': 1, 'constant': 0x00})
1893 
1894     def __delfield_cmd3(self): del self.__field_cmd3
1895 
1896     cmd3=property(__getfield_cmd3, __setfield_cmd3, __delfield_cmd3, None)
1897 
1898     def __getfield_padding(self):
1899         try: self.__field_padding
1900         except:
1901             self.__field_padding=DATA(**{'sizeinbytes': 130})
1902         return self.__field_padding.getvalue()
1903 
1904     def __setfield_padding(self, value):
1905         if isinstance(value,DATA):
1906             self.__field_padding=value
1907         else:
1908             self.__field_padding=DATA(value,**{'sizeinbytes': 130})
1909 
1910     def __delfield_padding(self): del self.__field_padding
1911 
1912     padding=property(__getfield_padding, __setfield_padding, __delfield_padding, None)
1913 
1914     def iscontainer(self):
1915         return True
1916 
1917     def containerelements(self):
1918         yield ('cmd', self.__field_cmd, None)
1919         yield ('cmd2', self.__field_cmd2, None)
1920         yield ('cmd3', self.__field_cmd3, None)
1921         yield ('padding', self.__field_padding, None)
1922 
1923 
1924 
1925 
1926 class readlockcoderesponse(BaseProtogenClass):
1927     __fields=['cmd', 'cmd2', 'cmd3', 'lockcode']
1928 
1929     def __init__(self, *args, **kwargs):
1930         dict={}
1931         # What was supplied to this function
1932         dict.update(kwargs)
1933         # Parent constructor
1934         super(readlockcoderesponse,self).__init__(**dict)
1935         if self.__class__ is readlockcoderesponse:
1936             self._update(args,dict)
1937 
1938 
1939     def getfields(self):
1940         return self.__fields
1941 
1942 
1943     def _update(self, args, kwargs):
1944         super(readlockcoderesponse,self)._update(args,kwargs)
1945         keys=kwargs.keys()
1946         for key in keys:
1947             if key in self.__fields:
1948                 setattr(self, key, kwargs[key])
1949                 del kwargs[key]
1950         # Were any unrecognized kwargs passed in?
1951         if __debug__:
1952             self._complainaboutunusedargs(readlockcoderesponse,kwargs)
1953         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1954         # Make all P fields that haven't already been constructed
1955 
1956 
1957     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1958         'Writes this packet to the supplied buffer'
1959         self._bufferstartoffset=buf.getcurrentoffset()
1960         self.__field_cmd.writetobuffer(buf)
1961         self.__field_cmd2.writetobuffer(buf)
1962         self.__field_cmd3.writetobuffer(buf)
1963         self.__field_lockcode.writetobuffer(buf)
1964         self._bufferendoffset=buf.getcurrentoffset()
1965         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1966 
1967 
1968     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1969         'Reads this packet from the supplied buffer'
1970         self._bufferstartoffset=buf.getcurrentoffset()
1971         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1972         self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x26})
1973         self.__field_cmd.readfrombuffer(buf)
1974         self.__field_cmd2=UINT(**{'sizeinbytes': 1, 'constant': 0x52})
1975         self.__field_cmd2.readfrombuffer(buf)
1976         self.__field_cmd3=UINT(**{'sizeinbytes': 1, 'constant': 0x00})
1977         self.__field_cmd3.readfrombuffer(buf)
1978         self.__field_lockcode=USTRING()
1979         self.__field_lockcode.readfrombuffer(buf)
1980         self._bufferendoffset=buf.getcurrentoffset()
1981 
1982 
1983     def __getfield_cmd(self):
1984         return self.__field_cmd.getvalue()
1985 
1986     def __setfield_cmd(self, value):
1987         if isinstance(value,UINT):
1988             self.__field_cmd=value
1989         else:
1990             self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'constant': 0x26})
1991 
1992     def __delfield_cmd(self): del self.__field_cmd
1993 
1994     cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None)
1995 
1996     def __getfield_cmd2(self):
1997         return self.__field_cmd2.getvalue()
1998 
1999     def __setfield_cmd2(self, value):
2000         if isinstance(value,UINT):
2001             self.__field_cmd2=value
2002         else:
2003             self.__field_cmd2=UINT(value,**{'sizeinbytes': 1, 'constant': 0x52})
2004 
2005     def __delfield_cmd2(self): del self.__field_cmd2
2006 
2007     cmd2=property(__getfield_cmd2, __setfield_cmd2, __delfield_cmd2, None)
2008 
2009     def __getfield_cmd3(self):
2010         return self.__field_cmd3.getvalue()
2011 
2012     def __setfield_cmd3(self, value):
2013         if isinstance(value,UINT):
2014             self.__field_cmd3=value
2015         else:
2016             self.__field_cmd3=UINT(value,**{'sizeinbytes': 1, 'constant': 0x00})
2017 
2018     def __delfield_cmd3(self): del self.__field_cmd3
2019 
2020     cmd3=property(__getfield_cmd3, __setfield_cmd3, __delfield_cmd3, None)
2021 
2022     def __getfield_lockcode(self):
2023         return self.__field_lockcode.getvalue()
2024 
2025     def __setfield_lockcode(self, value):
2026         if isinstance(value,USTRING):
2027             self.__field_lockcode=value
2028         else:
2029             self.__field_lockcode=USTRING(value,)
2030 
2031     def __delfield_lockcode(self): del self.__field_lockcode
2032 
2033     lockcode=property(__getfield_lockcode, __setfield_lockcode, __delfield_lockcode, None)
2034 
2035     def iscontainer(self):
2036         return True
2037 
2038     def containerelements(self):
2039         yield ('cmd', self.__field_cmd, None)
2040         yield ('cmd2', self.__field_cmd2, None)
2041         yield ('cmd3', self.__field_cmd3, None)
2042         yield ('lockcode', self.__field_lockcode, None)
2043 
2044 
2045 
2046 
2047