PyXR

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

0001 # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE
0002 
0003 """Various descriptions of data specific to LG phones"""
0004 
0005 from prototypes import *
0006 import re
0007 
0008 # We use LSB for all integer like fields
0009 UINT=UINTlsb
0010 BOOL=BOOLlsb
0011 
0012 class pbheader(BaseProtogenClass):
0013     __fields=['pbmode', 'command', 'sequence', 'flag']
0014 
0015     def __init__(self, *args, **kwargs):
0016         dict={}
0017         # What was supplied to this function
0018         dict.update(kwargs)
0019         # Parent constructor
0020         super(pbheader,self).__init__(**dict)
0021         if self.__class__ is pbheader:
0022             self._update(args,dict)
0023 
0024 
0025     def getfields(self):
0026         return self.__fields
0027 
0028 
0029     def _update(self, args, kwargs):
0030         super(pbheader,self)._update(args,kwargs)
0031         keys=kwargs.keys()
0032         for key in keys:
0033             if key in self.__fields:
0034                 setattr(self, key, kwargs[key])
0035                 del kwargs[key]
0036         # Were any unrecognized kwargs passed in?
0037         if __debug__:
0038             self._complainaboutunusedargs(pbheader,kwargs)
0039         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0040         # Make all P fields that haven't already been constructed
0041 
0042 
0043     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0044         'Writes this packet to the supplied buffer'
0045         self._bufferstartoffset=buf.getcurrentoffset()
0046         try: self.__field_pbmode
0047         except:
0048             self.__field_pbmode=UINT(**{'sizeinbytes': 1, 'constant': 0xff})
0049         self.__field_pbmode.writetobuffer(buf)
0050         self.__field_command.writetobuffer(buf)
0051         self.__field_sequence.writetobuffer(buf)
0052         self.__field_flag.writetobuffer(buf)
0053         self._bufferendoffset=buf.getcurrentoffset()
0054         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0055 
0056 
0057     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0058         'Reads this packet from the supplied buffer'
0059         self._bufferstartoffset=buf.getcurrentoffset()
0060         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0061         self.__field_pbmode=UINT(**{'sizeinbytes': 1, 'constant': 0xff})
0062         self.__field_pbmode.readfrombuffer(buf)
0063         self.__field_command=UINT(**{'sizeinbytes': 1})
0064         self.__field_command.readfrombuffer(buf)
0065         self.__field_sequence=UINT(**{'sizeinbytes': 1})
0066         self.__field_sequence.readfrombuffer(buf)
0067         self.__field_flag=UINT(**{'sizeinbytes': 1})
0068         self.__field_flag.readfrombuffer(buf)
0069         self._bufferendoffset=buf.getcurrentoffset()
0070 
0071 
0072     def __getfield_pbmode(self):
0073         try: self.__field_pbmode
0074         except:
0075             self.__field_pbmode=UINT(**{'sizeinbytes': 1, 'constant': 0xff})
0076         return self.__field_pbmode.getvalue()
0077 
0078     def __setfield_pbmode(self, value):
0079         if isinstance(value,UINT):
0080             self.__field_pbmode=value
0081         else:
0082             self.__field_pbmode=UINT(value,**{'sizeinbytes': 1, 'constant': 0xff})
0083 
0084     def __delfield_pbmode(self): del self.__field_pbmode
0085 
0086     pbmode=property(__getfield_pbmode, __setfield_pbmode, __delfield_pbmode, None)
0087 
0088     def __getfield_command(self):
0089         return self.__field_command.getvalue()
0090 
0091     def __setfield_command(self, value):
0092         if isinstance(value,UINT):
0093             self.__field_command=value
0094         else:
0095             self.__field_command=UINT(value,**{'sizeinbytes': 1})
0096 
0097     def __delfield_command(self): del self.__field_command
0098 
0099     command=property(__getfield_command, __setfield_command, __delfield_command, None)
0100 
0101     def __getfield_sequence(self):
0102         return self.__field_sequence.getvalue()
0103 
0104     def __setfield_sequence(self, value):
0105         if isinstance(value,UINT):
0106             self.__field_sequence=value
0107         else:
0108             self.__field_sequence=UINT(value,**{'sizeinbytes': 1})
0109 
0110     def __delfield_sequence(self): del self.__field_sequence
0111 
0112     sequence=property(__getfield_sequence, __setfield_sequence, __delfield_sequence, None)
0113 
0114     def __getfield_flag(self):
0115         return self.__field_flag.getvalue()
0116 
0117     def __setfield_flag(self, value):
0118         if isinstance(value,UINT):
0119             self.__field_flag=value
0120         else:
0121             self.__field_flag=UINT(value,**{'sizeinbytes': 1})
0122 
0123     def __delfield_flag(self): del self.__field_flag
0124 
0125     flag=property(__getfield_flag, __setfield_flag, __delfield_flag, None)
0126 
0127     def iscontainer(self):
0128         return True
0129 
0130     def containerelements(self):
0131         yield ('pbmode', self.__field_pbmode, None)
0132         yield ('command', self.__field_command, None)
0133         yield ('sequence', self.__field_sequence, None)
0134         yield ('flag', self.__field_flag, None)
0135 
0136 
0137 
0138 
0139 class pbstartsyncrequest(BaseProtogenClass):
0140     __fields=['header', 'pad']
0141 
0142     def __init__(self, *args, **kwargs):
0143         dict={}
0144         # What was supplied to this function
0145         dict.update(kwargs)
0146         # Parent constructor
0147         super(pbstartsyncrequest,self).__init__(**dict)
0148         if self.__class__ is pbstartsyncrequest:
0149             self._update(args,dict)
0150 
0151 
0152     def getfields(self):
0153         return self.__fields
0154 
0155 
0156     def _update(self, args, kwargs):
0157         super(pbstartsyncrequest,self)._update(args,kwargs)
0158         keys=kwargs.keys()
0159         for key in keys:
0160             if key in self.__fields:
0161                 setattr(self, key, kwargs[key])
0162                 del kwargs[key]
0163         # Were any unrecognized kwargs passed in?
0164         if __debug__:
0165             self._complainaboutunusedargs(pbstartsyncrequest,kwargs)
0166         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0167         # Make all P fields that haven't already been constructed
0168 
0169 
0170     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0171         'Writes this packet to the supplied buffer'
0172         self._bufferstartoffset=buf.getcurrentoffset()
0173         try: self.__field_header
0174         except:
0175             self.__field_header=pbheader(**{'command': 0x00, 'flag': 0x01})
0176         self.__field_header.writetobuffer(buf)
0177         try: self.__field_pad
0178         except:
0179             self.__field_pad=UNKNOWN(**{'sizeinbytes': 250})
0180         self.__field_pad.writetobuffer(buf)
0181         self._bufferendoffset=buf.getcurrentoffset()
0182         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0183 
0184 
0185     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0186         'Reads this packet from the supplied buffer'
0187         self._bufferstartoffset=buf.getcurrentoffset()
0188         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0189         self.__field_header=pbheader(**{'command': 0x00, 'flag': 0x01})
0190         self.__field_header.readfrombuffer(buf)
0191         self.__field_pad=UNKNOWN(**{'sizeinbytes': 250})
0192         self.__field_pad.readfrombuffer(buf)
0193         self._bufferendoffset=buf.getcurrentoffset()
0194 
0195 
0196     def __getfield_header(self):
0197         try: self.__field_header
0198         except:
0199             self.__field_header=pbheader(**{'command': 0x00, 'flag': 0x01})
0200         return self.__field_header.getvalue()
0201 
0202     def __setfield_header(self, value):
0203         if isinstance(value,pbheader):
0204             self.__field_header=value
0205         else:
0206             self.__field_header=pbheader(value,**{'command': 0x00, 'flag': 0x01})
0207 
0208     def __delfield_header(self): del self.__field_header
0209 
0210     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0211 
0212     def __getfield_pad(self):
0213         try: self.__field_pad
0214         except:
0215             self.__field_pad=UNKNOWN(**{'sizeinbytes': 250})
0216         return self.__field_pad.getvalue()
0217 
0218     def __setfield_pad(self, value):
0219         if isinstance(value,UNKNOWN):
0220             self.__field_pad=value
0221         else:
0222             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 250})
0223 
0224     def __delfield_pad(self): del self.__field_pad
0225 
0226     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
0227 
0228     def iscontainer(self):
0229         return True
0230 
0231     def containerelements(self):
0232         yield ('header', self.__field_header, None)
0233         yield ('pad', self.__field_pad, None)
0234 
0235 
0236 
0237 
0238 class pbstartsyncresponse(BaseProtogenClass):
0239     __fields=['header', 'unknown']
0240 
0241     def __init__(self, *args, **kwargs):
0242         dict={}
0243         # What was supplied to this function
0244         dict.update(kwargs)
0245         # Parent constructor
0246         super(pbstartsyncresponse,self).__init__(**dict)
0247         if self.__class__ is pbstartsyncresponse:
0248             self._update(args,dict)
0249 
0250 
0251     def getfields(self):
0252         return self.__fields
0253 
0254 
0255     def _update(self, args, kwargs):
0256         super(pbstartsyncresponse,self)._update(args,kwargs)
0257         keys=kwargs.keys()
0258         for key in keys:
0259             if key in self.__fields:
0260                 setattr(self, key, kwargs[key])
0261                 del kwargs[key]
0262         # Were any unrecognized kwargs passed in?
0263         if __debug__:
0264             self._complainaboutunusedargs(pbstartsyncresponse,kwargs)
0265         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0266         # Make all P fields that haven't already been constructed
0267 
0268 
0269     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0270         'Writes this packet to the supplied buffer'
0271         self._bufferstartoffset=buf.getcurrentoffset()
0272         self.__field_header.writetobuffer(buf)
0273         self.__field_unknown.writetobuffer(buf)
0274         self._bufferendoffset=buf.getcurrentoffset()
0275         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0276 
0277 
0278     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0279         'Reads this packet from the supplied buffer'
0280         self._bufferstartoffset=buf.getcurrentoffset()
0281         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0282         self.__field_header=pbheader()
0283         self.__field_header.readfrombuffer(buf)
0284         self.__field_unknown=UNKNOWN()
0285         self.__field_unknown.readfrombuffer(buf)
0286         self._bufferendoffset=buf.getcurrentoffset()
0287 
0288 
0289     def __getfield_header(self):
0290         return self.__field_header.getvalue()
0291 
0292     def __setfield_header(self, value):
0293         if isinstance(value,pbheader):
0294             self.__field_header=value
0295         else:
0296             self.__field_header=pbheader(value,)
0297 
0298     def __delfield_header(self): del self.__field_header
0299 
0300     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0301 
0302     def __getfield_unknown(self):
0303         return self.__field_unknown.getvalue()
0304 
0305     def __setfield_unknown(self, value):
0306         if isinstance(value,UNKNOWN):
0307             self.__field_unknown=value
0308         else:
0309             self.__field_unknown=UNKNOWN(value,)
0310 
0311     def __delfield_unknown(self): del self.__field_unknown
0312 
0313     unknown=property(__getfield_unknown, __setfield_unknown, __delfield_unknown, None)
0314 
0315     def iscontainer(self):
0316         return True
0317 
0318     def containerelements(self):
0319         yield ('header', self.__field_header, None)
0320         yield ('unknown', self.__field_unknown, None)
0321 
0322 
0323 
0324 
0325 class pbendsyncrequest(BaseProtogenClass):
0326     __fields=['header', 'pad']
0327 
0328     def __init__(self, *args, **kwargs):
0329         dict={}
0330         # What was supplied to this function
0331         dict.update(kwargs)
0332         # Parent constructor
0333         super(pbendsyncrequest,self).__init__(**dict)
0334         if self.__class__ is pbendsyncrequest:
0335             self._update(args,dict)
0336 
0337 
0338     def getfields(self):
0339         return self.__fields
0340 
0341 
0342     def _update(self, args, kwargs):
0343         super(pbendsyncrequest,self)._update(args,kwargs)
0344         keys=kwargs.keys()
0345         for key in keys:
0346             if key in self.__fields:
0347                 setattr(self, key, kwargs[key])
0348                 del kwargs[key]
0349         # Were any unrecognized kwargs passed in?
0350         if __debug__:
0351             self._complainaboutunusedargs(pbendsyncrequest,kwargs)
0352         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0353         # Make all P fields that haven't already been constructed
0354 
0355 
0356     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0357         'Writes this packet to the supplied buffer'
0358         self._bufferstartoffset=buf.getcurrentoffset()
0359         try: self.__field_header
0360         except:
0361             self.__field_header=pbheader(**{'command': 0x07, 'flag': 0x01})
0362         self.__field_header.writetobuffer(buf)
0363         try: self.__field_pad
0364         except:
0365             self.__field_pad=UNKNOWN(**{'sizeinbytes': 6})
0366         self.__field_pad.writetobuffer(buf)
0367         self._bufferendoffset=buf.getcurrentoffset()
0368         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0369 
0370 
0371     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0372         'Reads this packet from the supplied buffer'
0373         self._bufferstartoffset=buf.getcurrentoffset()
0374         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0375         self.__field_header=pbheader(**{'command': 0x07, 'flag': 0x01})
0376         self.__field_header.readfrombuffer(buf)
0377         self.__field_pad=UNKNOWN(**{'sizeinbytes': 6})
0378         self.__field_pad.readfrombuffer(buf)
0379         self._bufferendoffset=buf.getcurrentoffset()
0380 
0381 
0382     def __getfield_header(self):
0383         try: self.__field_header
0384         except:
0385             self.__field_header=pbheader(**{'command': 0x07, 'flag': 0x01})
0386         return self.__field_header.getvalue()
0387 
0388     def __setfield_header(self, value):
0389         if isinstance(value,pbheader):
0390             self.__field_header=value
0391         else:
0392             self.__field_header=pbheader(value,**{'command': 0x07, 'flag': 0x01})
0393 
0394     def __delfield_header(self): del self.__field_header
0395 
0396     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0397 
0398     def __getfield_pad(self):
0399         try: self.__field_pad
0400         except:
0401             self.__field_pad=UNKNOWN(**{'sizeinbytes': 6})
0402         return self.__field_pad.getvalue()
0403 
0404     def __setfield_pad(self, value):
0405         if isinstance(value,UNKNOWN):
0406             self.__field_pad=value
0407         else:
0408             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 6})
0409 
0410     def __delfield_pad(self): del self.__field_pad
0411 
0412     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
0413 
0414     def iscontainer(self):
0415         return True
0416 
0417     def containerelements(self):
0418         yield ('header', self.__field_header, None)
0419         yield ('pad', self.__field_pad, None)
0420 
0421 
0422 
0423 
0424 class pbendsyncresponse(BaseProtogenClass):
0425     __fields=['header', 'unknown']
0426 
0427     def __init__(self, *args, **kwargs):
0428         dict={}
0429         # What was supplied to this function
0430         dict.update(kwargs)
0431         # Parent constructor
0432         super(pbendsyncresponse,self).__init__(**dict)
0433         if self.__class__ is pbendsyncresponse:
0434             self._update(args,dict)
0435 
0436 
0437     def getfields(self):
0438         return self.__fields
0439 
0440 
0441     def _update(self, args, kwargs):
0442         super(pbendsyncresponse,self)._update(args,kwargs)
0443         keys=kwargs.keys()
0444         for key in keys:
0445             if key in self.__fields:
0446                 setattr(self, key, kwargs[key])
0447                 del kwargs[key]
0448         # Were any unrecognized kwargs passed in?
0449         if __debug__:
0450             self._complainaboutunusedargs(pbendsyncresponse,kwargs)
0451         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0452         # Make all P fields that haven't already been constructed
0453 
0454 
0455     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0456         'Writes this packet to the supplied buffer'
0457         self._bufferstartoffset=buf.getcurrentoffset()
0458         self.__field_header.writetobuffer(buf)
0459         self.__field_unknown.writetobuffer(buf)
0460         self._bufferendoffset=buf.getcurrentoffset()
0461         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0462 
0463 
0464     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0465         'Reads this packet from the supplied buffer'
0466         self._bufferstartoffset=buf.getcurrentoffset()
0467         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0468         self.__field_header=pbheader()
0469         self.__field_header.readfrombuffer(buf)
0470         self.__field_unknown=UNKNOWN()
0471         self.__field_unknown.readfrombuffer(buf)
0472         self._bufferendoffset=buf.getcurrentoffset()
0473 
0474 
0475     def __getfield_header(self):
0476         return self.__field_header.getvalue()
0477 
0478     def __setfield_header(self, value):
0479         if isinstance(value,pbheader):
0480             self.__field_header=value
0481         else:
0482             self.__field_header=pbheader(value,)
0483 
0484     def __delfield_header(self): del self.__field_header
0485 
0486     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0487 
0488     def __getfield_unknown(self):
0489         return self.__field_unknown.getvalue()
0490 
0491     def __setfield_unknown(self, value):
0492         if isinstance(value,UNKNOWN):
0493             self.__field_unknown=value
0494         else:
0495             self.__field_unknown=UNKNOWN(value,)
0496 
0497     def __delfield_unknown(self): del self.__field_unknown
0498 
0499     unknown=property(__getfield_unknown, __setfield_unknown, __delfield_unknown, None)
0500 
0501     def iscontainer(self):
0502         return True
0503 
0504     def containerelements(self):
0505         yield ('header', self.__field_header, None)
0506         yield ('unknown', self.__field_unknown, None)
0507 
0508 
0509 
0510 
0511 class pbinforequest(BaseProtogenClass):
0512     "Random information about the phone"
0513     __fields=['header', 'pad']
0514 
0515     def __init__(self, *args, **kwargs):
0516         dict={}
0517         # What was supplied to this function
0518         dict.update(kwargs)
0519         # Parent constructor
0520         super(pbinforequest,self).__init__(**dict)
0521         if self.__class__ is pbinforequest:
0522             self._update(args,dict)
0523 
0524 
0525     def getfields(self):
0526         return self.__fields
0527 
0528 
0529     def _update(self, args, kwargs):
0530         super(pbinforequest,self)._update(args,kwargs)
0531         keys=kwargs.keys()
0532         for key in keys:
0533             if key in self.__fields:
0534                 setattr(self, key, kwargs[key])
0535                 del kwargs[key]
0536         # Were any unrecognized kwargs passed in?
0537         if __debug__:
0538             self._complainaboutunusedargs(pbinforequest,kwargs)
0539         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0540         # Make all P fields that haven't already been constructed
0541 
0542 
0543     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0544         'Writes this packet to the supplied buffer'
0545         self._bufferstartoffset=buf.getcurrentoffset()
0546         try: self.__field_header
0547         except:
0548             self.__field_header=pbheader(**{'command': 0x15, 'flag': 0x01})
0549         self.__field_header.writetobuffer(buf)
0550         try: self.__field_pad
0551         except:
0552             self.__field_pad=UNKNOWN(**{'sizeinbytes': 6})
0553         self.__field_pad.writetobuffer(buf)
0554         self._bufferendoffset=buf.getcurrentoffset()
0555         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0556 
0557 
0558     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0559         'Reads this packet from the supplied buffer'
0560         self._bufferstartoffset=buf.getcurrentoffset()
0561         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0562         self.__field_header=pbheader(**{'command': 0x15, 'flag': 0x01})
0563         self.__field_header.readfrombuffer(buf)
0564         self.__field_pad=UNKNOWN(**{'sizeinbytes': 6})
0565         self.__field_pad.readfrombuffer(buf)
0566         self._bufferendoffset=buf.getcurrentoffset()
0567 
0568 
0569     def __getfield_header(self):
0570         try: self.__field_header
0571         except:
0572             self.__field_header=pbheader(**{'command': 0x15, 'flag': 0x01})
0573         return self.__field_header.getvalue()
0574 
0575     def __setfield_header(self, value):
0576         if isinstance(value,pbheader):
0577             self.__field_header=value
0578         else:
0579             self.__field_header=pbheader(value,**{'command': 0x15, 'flag': 0x01})
0580 
0581     def __delfield_header(self): del self.__field_header
0582 
0583     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0584 
0585     def __getfield_pad(self):
0586         try: self.__field_pad
0587         except:
0588             self.__field_pad=UNKNOWN(**{'sizeinbytes': 6})
0589         return self.__field_pad.getvalue()
0590 
0591     def __setfield_pad(self, value):
0592         if isinstance(value,UNKNOWN):
0593             self.__field_pad=value
0594         else:
0595             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 6})
0596 
0597     def __delfield_pad(self): del self.__field_pad
0598 
0599     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
0600 
0601     def iscontainer(self):
0602         return True
0603 
0604     def containerelements(self):
0605         yield ('header', self.__field_header, None)
0606         yield ('pad', self.__field_pad, None)
0607 
0608 
0609 
0610 
0611 class pbinforesponse(BaseProtogenClass):
0612     __fields=['header', 'dunno1', 'something1', 'firstentry', 'dunno2', 'numentries', 'dunno3', 'lastentry', 'dunno4', 'esn', 'phonesoftware']
0613 
0614     def __init__(self, *args, **kwargs):
0615         dict={}
0616         # What was supplied to this function
0617         dict.update(kwargs)
0618         # Parent constructor
0619         super(pbinforesponse,self).__init__(**dict)
0620         if self.__class__ is pbinforesponse:
0621             self._update(args,dict)
0622 
0623 
0624     def getfields(self):
0625         return self.__fields
0626 
0627 
0628     def _update(self, args, kwargs):
0629         super(pbinforesponse,self)._update(args,kwargs)
0630         keys=kwargs.keys()
0631         for key in keys:
0632             if key in self.__fields:
0633                 setattr(self, key, kwargs[key])
0634                 del kwargs[key]
0635         # Were any unrecognized kwargs passed in?
0636         if __debug__:
0637             self._complainaboutunusedargs(pbinforesponse,kwargs)
0638         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0639         # Make all P fields that haven't already been constructed
0640 
0641 
0642     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0643         'Writes this packet to the supplied buffer'
0644         self._bufferstartoffset=buf.getcurrentoffset()
0645         self.__field_header.writetobuffer(buf)
0646         self.__field_dunno1.writetobuffer(buf)
0647         self.__field_something1.writetobuffer(buf)
0648         self.__field_firstentry.writetobuffer(buf)
0649         self.__field_dunno2.writetobuffer(buf)
0650         self.__field_numentries.writetobuffer(buf)
0651         self.__field_dunno3.writetobuffer(buf)
0652         self.__field_lastentry.writetobuffer(buf)
0653         self.__field_dunno4.writetobuffer(buf)
0654         self.__field_esn.writetobuffer(buf)
0655         self.__field_phonesoftware.writetobuffer(buf)
0656         self._bufferendoffset=buf.getcurrentoffset()
0657         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0658 
0659 
0660     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0661         'Reads this packet from the supplied buffer'
0662         self._bufferstartoffset=buf.getcurrentoffset()
0663         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0664         self.__field_header=pbheader()
0665         self.__field_header.readfrombuffer(buf)
0666         self.__field_dunno1=UNKNOWN(**{'sizeinbytes': 4})
0667         self.__field_dunno1.readfrombuffer(buf)
0668         self.__field_something1=UINT(**{'sizeinbytes': 2})
0669         self.__field_something1.readfrombuffer(buf)
0670         self.__field_firstentry=UINT(**{'sizeinbytes': 4})
0671         self.__field_firstentry.readfrombuffer(buf)
0672         self.__field_dunno2=UNKNOWN(**{'sizeinbytes': 4})
0673         self.__field_dunno2.readfrombuffer(buf)
0674         self.__field_numentries=UINT(**{'sizeinbytes': 4})
0675         self.__field_numentries.readfrombuffer(buf)
0676         self.__field_dunno3=UNKNOWN(**{'sizeinbytes': 20})
0677         self.__field_dunno3.readfrombuffer(buf)
0678         self.__field_lastentry=UINT(**{'sizeinbytes': 4})
0679         self.__field_lastentry.readfrombuffer(buf)
0680         self.__field_dunno4=UNKNOWN(**{'sizeinbytes': 20})
0681         self.__field_dunno4.readfrombuffer(buf)
0682         self.__field_esn=UINT(**{'sizeinbytes': 4})
0683         self.__field_esn.readfrombuffer(buf)
0684         self.__field_phonesoftware=USTRING()
0685         self.__field_phonesoftware.readfrombuffer(buf)
0686         self._bufferendoffset=buf.getcurrentoffset()
0687 
0688 
0689     def __getfield_header(self):
0690         return self.__field_header.getvalue()
0691 
0692     def __setfield_header(self, value):
0693         if isinstance(value,pbheader):
0694             self.__field_header=value
0695         else:
0696             self.__field_header=pbheader(value,)
0697 
0698     def __delfield_header(self): del self.__field_header
0699 
0700     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0701 
0702     def __getfield_dunno1(self):
0703         return self.__field_dunno1.getvalue()
0704 
0705     def __setfield_dunno1(self, value):
0706         if isinstance(value,UNKNOWN):
0707             self.__field_dunno1=value
0708         else:
0709             self.__field_dunno1=UNKNOWN(value,**{'sizeinbytes': 4})
0710 
0711     def __delfield_dunno1(self): del self.__field_dunno1
0712 
0713     dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None)
0714 
0715     def __getfield_something1(self):
0716         return self.__field_something1.getvalue()
0717 
0718     def __setfield_something1(self, value):
0719         if isinstance(value,UINT):
0720             self.__field_something1=value
0721         else:
0722             self.__field_something1=UINT(value,**{'sizeinbytes': 2})
0723 
0724     def __delfield_something1(self): del self.__field_something1
0725 
0726     something1=property(__getfield_something1, __setfield_something1, __delfield_something1, None)
0727 
0728     def __getfield_firstentry(self):
0729         return self.__field_firstentry.getvalue()
0730 
0731     def __setfield_firstentry(self, value):
0732         if isinstance(value,UINT):
0733             self.__field_firstentry=value
0734         else:
0735             self.__field_firstentry=UINT(value,**{'sizeinbytes': 4})
0736 
0737     def __delfield_firstentry(self): del self.__field_firstentry
0738 
0739     firstentry=property(__getfield_firstentry, __setfield_firstentry, __delfield_firstentry, None)
0740 
0741     def __getfield_dunno2(self):
0742         return self.__field_dunno2.getvalue()
0743 
0744     def __setfield_dunno2(self, value):
0745         if isinstance(value,UNKNOWN):
0746             self.__field_dunno2=value
0747         else:
0748             self.__field_dunno2=UNKNOWN(value,**{'sizeinbytes': 4})
0749 
0750     def __delfield_dunno2(self): del self.__field_dunno2
0751 
0752     dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None)
0753 
0754     def __getfield_numentries(self):
0755         return self.__field_numentries.getvalue()
0756 
0757     def __setfield_numentries(self, value):
0758         if isinstance(value,UINT):
0759             self.__field_numentries=value
0760         else:
0761             self.__field_numentries=UINT(value,**{'sizeinbytes': 4})
0762 
0763     def __delfield_numentries(self): del self.__field_numentries
0764 
0765     numentries=property(__getfield_numentries, __setfield_numentries, __delfield_numentries, None)
0766 
0767     def __getfield_dunno3(self):
0768         return self.__field_dunno3.getvalue()
0769 
0770     def __setfield_dunno3(self, value):
0771         if isinstance(value,UNKNOWN):
0772             self.__field_dunno3=value
0773         else:
0774             self.__field_dunno3=UNKNOWN(value,**{'sizeinbytes': 20})
0775 
0776     def __delfield_dunno3(self): del self.__field_dunno3
0777 
0778     dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None)
0779 
0780     def __getfield_lastentry(self):
0781         return self.__field_lastentry.getvalue()
0782 
0783     def __setfield_lastentry(self, value):
0784         if isinstance(value,UINT):
0785             self.__field_lastentry=value
0786         else:
0787             self.__field_lastentry=UINT(value,**{'sizeinbytes': 4})
0788 
0789     def __delfield_lastentry(self): del self.__field_lastentry
0790 
0791     lastentry=property(__getfield_lastentry, __setfield_lastentry, __delfield_lastentry, None)
0792 
0793     def __getfield_dunno4(self):
0794         return self.__field_dunno4.getvalue()
0795 
0796     def __setfield_dunno4(self, value):
0797         if isinstance(value,UNKNOWN):
0798             self.__field_dunno4=value
0799         else:
0800             self.__field_dunno4=UNKNOWN(value,**{'sizeinbytes': 20})
0801 
0802     def __delfield_dunno4(self): del self.__field_dunno4
0803 
0804     dunno4=property(__getfield_dunno4, __setfield_dunno4, __delfield_dunno4, None)
0805 
0806     def __getfield_esn(self):
0807         return self.__field_esn.getvalue()
0808 
0809     def __setfield_esn(self, value):
0810         if isinstance(value,UINT):
0811             self.__field_esn=value
0812         else:
0813             self.__field_esn=UINT(value,**{'sizeinbytes': 4})
0814 
0815     def __delfield_esn(self): del self.__field_esn
0816 
0817     esn=property(__getfield_esn, __setfield_esn, __delfield_esn, None)
0818 
0819     def __getfield_phonesoftware(self):
0820         return self.__field_phonesoftware.getvalue()
0821 
0822     def __setfield_phonesoftware(self, value):
0823         if isinstance(value,USTRING):
0824             self.__field_phonesoftware=value
0825         else:
0826             self.__field_phonesoftware=USTRING(value,)
0827 
0828     def __delfield_phonesoftware(self): del self.__field_phonesoftware
0829 
0830     phonesoftware=property(__getfield_phonesoftware, __setfield_phonesoftware, __delfield_phonesoftware, None)
0831 
0832     def iscontainer(self):
0833         return True
0834 
0835     def containerelements(self):
0836         yield ('header', self.__field_header, None)
0837         yield ('dunno1', self.__field_dunno1, None)
0838         yield ('something1', self.__field_something1, None)
0839         yield ('firstentry', self.__field_firstentry, None)
0840         yield ('dunno2', self.__field_dunno2, None)
0841         yield ('numentries', self.__field_numentries, None)
0842         yield ('dunno3', self.__field_dunno3, None)
0843         yield ('lastentry', self.__field_lastentry, None)
0844         yield ('dunno4', self.__field_dunno4, None)
0845         yield ('esn', self.__field_esn, None)
0846         yield ('phonesoftware', self.__field_phonesoftware, None)
0847 
0848 
0849 
0850 
0851 class pbinitrequest(BaseProtogenClass):
0852     "Moves cursor to begining of phonebook"
0853     __fields=['header', 'pad']
0854 
0855     def __init__(self, *args, **kwargs):
0856         dict={}
0857         # What was supplied to this function
0858         dict.update(kwargs)
0859         # Parent constructor
0860         super(pbinitrequest,self).__init__(**dict)
0861         if self.__class__ is pbinitrequest:
0862             self._update(args,dict)
0863 
0864 
0865     def getfields(self):
0866         return self.__fields
0867 
0868 
0869     def _update(self, args, kwargs):
0870         super(pbinitrequest,self)._update(args,kwargs)
0871         keys=kwargs.keys()
0872         for key in keys:
0873             if key in self.__fields:
0874                 setattr(self, key, kwargs[key])
0875                 del kwargs[key]
0876         # Were any unrecognized kwargs passed in?
0877         if __debug__:
0878             self._complainaboutunusedargs(pbinitrequest,kwargs)
0879         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0880         # Make all P fields that haven't already been constructed
0881 
0882 
0883     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0884         'Writes this packet to the supplied buffer'
0885         self._bufferstartoffset=buf.getcurrentoffset()
0886         try: self.__field_header
0887         except:
0888             self.__field_header=pbheader(**{'command': 0x11, 'flag': 0x01})
0889         self.__field_header.writetobuffer(buf)
0890         try: self.__field_pad
0891         except:
0892             self.__field_pad=UNKNOWN(**{'sizeinbytes': 6})
0893         self.__field_pad.writetobuffer(buf)
0894         self._bufferendoffset=buf.getcurrentoffset()
0895         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0896 
0897 
0898     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0899         'Reads this packet from the supplied buffer'
0900         self._bufferstartoffset=buf.getcurrentoffset()
0901         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0902         self.__field_header=pbheader(**{'command': 0x11, 'flag': 0x01})
0903         self.__field_header.readfrombuffer(buf)
0904         self.__field_pad=UNKNOWN(**{'sizeinbytes': 6})
0905         self.__field_pad.readfrombuffer(buf)
0906         self._bufferendoffset=buf.getcurrentoffset()
0907 
0908 
0909     def __getfield_header(self):
0910         try: self.__field_header
0911         except:
0912             self.__field_header=pbheader(**{'command': 0x11, 'flag': 0x01})
0913         return self.__field_header.getvalue()
0914 
0915     def __setfield_header(self, value):
0916         if isinstance(value,pbheader):
0917             self.__field_header=value
0918         else:
0919             self.__field_header=pbheader(value,**{'command': 0x11, 'flag': 0x01})
0920 
0921     def __delfield_header(self): del self.__field_header
0922 
0923     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0924 
0925     def __getfield_pad(self):
0926         try: self.__field_pad
0927         except:
0928             self.__field_pad=UNKNOWN(**{'sizeinbytes': 6})
0929         return self.__field_pad.getvalue()
0930 
0931     def __setfield_pad(self, value):
0932         if isinstance(value,UNKNOWN):
0933             self.__field_pad=value
0934         else:
0935             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 6})
0936 
0937     def __delfield_pad(self): del self.__field_pad
0938 
0939     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
0940 
0941     def iscontainer(self):
0942         return True
0943 
0944     def containerelements(self):
0945         yield ('header', self.__field_header, None)
0946         yield ('pad', self.__field_pad, None)
0947 
0948 
0949 
0950 
0951 class pbinitresponse(BaseProtogenClass):
0952     __fields=['header', 'dunno']
0953 
0954     def __init__(self, *args, **kwargs):
0955         dict={}
0956         # What was supplied to this function
0957         dict.update(kwargs)
0958         # Parent constructor
0959         super(pbinitresponse,self).__init__(**dict)
0960         if self.__class__ is pbinitresponse:
0961             self._update(args,dict)
0962 
0963 
0964     def getfields(self):
0965         return self.__fields
0966 
0967 
0968     def _update(self, args, kwargs):
0969         super(pbinitresponse,self)._update(args,kwargs)
0970         keys=kwargs.keys()
0971         for key in keys:
0972             if key in self.__fields:
0973                 setattr(self, key, kwargs[key])
0974                 del kwargs[key]
0975         # Were any unrecognized kwargs passed in?
0976         if __debug__:
0977             self._complainaboutunusedargs(pbinitresponse,kwargs)
0978         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0979         # Make all P fields that haven't already been constructed
0980 
0981 
0982     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0983         'Writes this packet to the supplied buffer'
0984         self._bufferstartoffset=buf.getcurrentoffset()
0985         self.__field_header.writetobuffer(buf)
0986         self.__field_dunno.writetobuffer(buf)
0987         self._bufferendoffset=buf.getcurrentoffset()
0988         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0989 
0990 
0991     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0992         'Reads this packet from the supplied buffer'
0993         self._bufferstartoffset=buf.getcurrentoffset()
0994         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0995         self.__field_header=pbheader()
0996         self.__field_header.readfrombuffer(buf)
0997         self.__field_dunno=UNKNOWN()
0998         self.__field_dunno.readfrombuffer(buf)
0999         self._bufferendoffset=buf.getcurrentoffset()
1000 
1001 
1002     def __getfield_header(self):
1003         return self.__field_header.getvalue()
1004 
1005     def __setfield_header(self, value):
1006         if isinstance(value,pbheader):
1007             self.__field_header=value
1008         else:
1009             self.__field_header=pbheader(value,)
1010 
1011     def __delfield_header(self): del self.__field_header
1012 
1013     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1014 
1015     def __getfield_dunno(self):
1016         return self.__field_dunno.getvalue()
1017 
1018     def __setfield_dunno(self, value):
1019         if isinstance(value,UNKNOWN):
1020             self.__field_dunno=value
1021         else:
1022             self.__field_dunno=UNKNOWN(value,)
1023 
1024     def __delfield_dunno(self): del self.__field_dunno
1025 
1026     dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, None)
1027 
1028     def iscontainer(self):
1029         return True
1030 
1031     def containerelements(self):
1032         yield ('header', self.__field_header, None)
1033         yield ('dunno', self.__field_dunno, None)
1034 
1035 
1036 
1037 
1038 class pbreadentryrequest(BaseProtogenClass):
1039     __fields=['header', 'pad']
1040 
1041     def __init__(self, *args, **kwargs):
1042         dict={}
1043         # What was supplied to this function
1044         dict.update(kwargs)
1045         # Parent constructor
1046         super(pbreadentryrequest,self).__init__(**dict)
1047         if self.__class__ is pbreadentryrequest:
1048             self._update(args,dict)
1049 
1050 
1051     def getfields(self):
1052         return self.__fields
1053 
1054 
1055     def _update(self, args, kwargs):
1056         super(pbreadentryrequest,self)._update(args,kwargs)
1057         keys=kwargs.keys()
1058         for key in keys:
1059             if key in self.__fields:
1060                 setattr(self, key, kwargs[key])
1061                 del kwargs[key]
1062         # Were any unrecognized kwargs passed in?
1063         if __debug__:
1064             self._complainaboutunusedargs(pbreadentryrequest,kwargs)
1065         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1066         # Make all P fields that haven't already been constructed
1067 
1068 
1069     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1070         'Writes this packet to the supplied buffer'
1071         self._bufferstartoffset=buf.getcurrentoffset()
1072         try: self.__field_header
1073         except:
1074             self.__field_header=pbheader(**{'command': 0x13, 'flag': 0x01})
1075         self.__field_header.writetobuffer(buf)
1076         try: self.__field_pad
1077         except:
1078             self.__field_pad=UNKNOWN(**{'sizeinbytes': 6})
1079         self.__field_pad.writetobuffer(buf)
1080         self._bufferendoffset=buf.getcurrentoffset()
1081         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1082 
1083 
1084     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1085         'Reads this packet from the supplied buffer'
1086         self._bufferstartoffset=buf.getcurrentoffset()
1087         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1088         self.__field_header=pbheader(**{'command': 0x13, 'flag': 0x01})
1089         self.__field_header.readfrombuffer(buf)
1090         self.__field_pad=UNKNOWN(**{'sizeinbytes': 6})
1091         self.__field_pad.readfrombuffer(buf)
1092         self._bufferendoffset=buf.getcurrentoffset()
1093 
1094 
1095     def __getfield_header(self):
1096         try: self.__field_header
1097         except:
1098             self.__field_header=pbheader(**{'command': 0x13, 'flag': 0x01})
1099         return self.__field_header.getvalue()
1100 
1101     def __setfield_header(self, value):
1102         if isinstance(value,pbheader):
1103             self.__field_header=value
1104         else:
1105             self.__field_header=pbheader(value,**{'command': 0x13, 'flag': 0x01})
1106 
1107     def __delfield_header(self): del self.__field_header
1108 
1109     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1110 
1111     def __getfield_pad(self):
1112         try: self.__field_pad
1113         except:
1114             self.__field_pad=UNKNOWN(**{'sizeinbytes': 6})
1115         return self.__field_pad.getvalue()
1116 
1117     def __setfield_pad(self, value):
1118         if isinstance(value,UNKNOWN):
1119             self.__field_pad=value
1120         else:
1121             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 6})
1122 
1123     def __delfield_pad(self): del self.__field_pad
1124 
1125     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
1126 
1127     def iscontainer(self):
1128         return True
1129 
1130     def containerelements(self):
1131         yield ('header', self.__field_header, None)
1132         yield ('pad', self.__field_pad, None)
1133 
1134 
1135 
1136 
1137 class pbnextentryrequest(BaseProtogenClass):
1138     __fields=['header', 'pad']
1139 
1140     def __init__(self, *args, **kwargs):
1141         dict={}
1142         # What was supplied to this function
1143         dict.update(kwargs)
1144         # Parent constructor
1145         super(pbnextentryrequest,self).__init__(**dict)
1146         if self.__class__ is pbnextentryrequest:
1147             self._update(args,dict)
1148 
1149 
1150     def getfields(self):
1151         return self.__fields
1152 
1153 
1154     def _update(self, args, kwargs):
1155         super(pbnextentryrequest,self)._update(args,kwargs)
1156         keys=kwargs.keys()
1157         for key in keys:
1158             if key in self.__fields:
1159                 setattr(self, key, kwargs[key])
1160                 del kwargs[key]
1161         # Were any unrecognized kwargs passed in?
1162         if __debug__:
1163             self._complainaboutunusedargs(pbnextentryrequest,kwargs)
1164         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1165         # Make all P fields that haven't already been constructed
1166 
1167 
1168     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1169         'Writes this packet to the supplied buffer'
1170         self._bufferstartoffset=buf.getcurrentoffset()
1171         try: self.__field_header
1172         except:
1173             self.__field_header=pbheader(**{'command': 0x12, 'flag': 0x01})
1174         self.__field_header.writetobuffer(buf)
1175         try: self.__field_pad
1176         except:
1177             self.__field_pad=UNKNOWN(**{'sizeinbytes': 6})
1178         self.__field_pad.writetobuffer(buf)
1179         self._bufferendoffset=buf.getcurrentoffset()
1180         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1181 
1182 
1183     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1184         'Reads this packet from the supplied buffer'
1185         self._bufferstartoffset=buf.getcurrentoffset()
1186         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1187         self.__field_header=pbheader(**{'command': 0x12, 'flag': 0x01})
1188         self.__field_header.readfrombuffer(buf)
1189         self.__field_pad=UNKNOWN(**{'sizeinbytes': 6})
1190         self.__field_pad.readfrombuffer(buf)
1191         self._bufferendoffset=buf.getcurrentoffset()
1192 
1193 
1194     def __getfield_header(self):
1195         try: self.__field_header
1196         except:
1197             self.__field_header=pbheader(**{'command': 0x12, 'flag': 0x01})
1198         return self.__field_header.getvalue()
1199 
1200     def __setfield_header(self, value):
1201         if isinstance(value,pbheader):
1202             self.__field_header=value
1203         else:
1204             self.__field_header=pbheader(value,**{'command': 0x12, 'flag': 0x01})
1205 
1206     def __delfield_header(self): del self.__field_header
1207 
1208     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1209 
1210     def __getfield_pad(self):
1211         try: self.__field_pad
1212         except:
1213             self.__field_pad=UNKNOWN(**{'sizeinbytes': 6})
1214         return self.__field_pad.getvalue()
1215 
1216     def __setfield_pad(self, value):
1217         if isinstance(value,UNKNOWN):
1218             self.__field_pad=value
1219         else:
1220             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 6})
1221 
1222     def __delfield_pad(self): del self.__field_pad
1223 
1224     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
1225 
1226     def iscontainer(self):
1227         return True
1228 
1229     def containerelements(self):
1230         yield ('header', self.__field_header, None)
1231         yield ('pad', self.__field_pad, None)
1232 
1233 
1234 
1235 
1236 class pbnextentryresponse(BaseProtogenClass):
1237     __fields=['header', 'serial', 'datalen', 'data', 'randomgunk']
1238 
1239     def __init__(self, *args, **kwargs):
1240         dict={}
1241         # What was supplied to this function
1242         dict.update(kwargs)
1243         # Parent constructor
1244         super(pbnextentryresponse,self).__init__(**dict)
1245         if self.__class__ is pbnextentryresponse:
1246             self._update(args,dict)
1247 
1248 
1249     def getfields(self):
1250         return self.__fields
1251 
1252 
1253     def _update(self, args, kwargs):
1254         super(pbnextentryresponse,self)._update(args,kwargs)
1255         keys=kwargs.keys()
1256         for key in keys:
1257             if key in self.__fields:
1258                 setattr(self, key, kwargs[key])
1259                 del kwargs[key]
1260         # Were any unrecognized kwargs passed in?
1261         if __debug__:
1262             self._complainaboutunusedargs(pbnextentryresponse,kwargs)
1263         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1264         # Make all P fields that haven't already been constructed
1265 
1266 
1267     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1268         'Writes this packet to the supplied buffer'
1269         self._bufferstartoffset=buf.getcurrentoffset()
1270         self.__field_header.writetobuffer(buf)
1271         self.__field_serial.writetobuffer(buf)
1272         self.__field_datalen.writetobuffer(buf)
1273         self.__field_data.writetobuffer(buf)
1274         self.__field_randomgunk.writetobuffer(buf)
1275         self._bufferendoffset=buf.getcurrentoffset()
1276         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1277 
1278 
1279     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1280         'Reads this packet from the supplied buffer'
1281         self._bufferstartoffset=buf.getcurrentoffset()
1282         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1283         self.__field_header=pbheader()
1284         self.__field_header.readfrombuffer(buf)
1285         self.__field_serial=UINT(**{'sizeinbytes': 4})
1286         self.__field_serial.readfrombuffer(buf)
1287         self.__field_datalen=UINT(**{'sizeinbytes': 2})
1288         self.__field_datalen.readfrombuffer(buf)
1289         self.__field_data=DATA(**{'sizeinbytes': self.datalen})
1290         self.__field_data.readfrombuffer(buf)
1291         self.__field_randomgunk=UNKNOWN()
1292         self.__field_randomgunk.readfrombuffer(buf)
1293         self._bufferendoffset=buf.getcurrentoffset()
1294 
1295 
1296     def __getfield_header(self):
1297         return self.__field_header.getvalue()
1298 
1299     def __setfield_header(self, value):
1300         if isinstance(value,pbheader):
1301             self.__field_header=value
1302         else:
1303             self.__field_header=pbheader(value,)
1304 
1305     def __delfield_header(self): del self.__field_header
1306 
1307     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1308 
1309     def __getfield_serial(self):
1310         return self.__field_serial.getvalue()
1311 
1312     def __setfield_serial(self, value):
1313         if isinstance(value,UINT):
1314             self.__field_serial=value
1315         else:
1316             self.__field_serial=UINT(value,**{'sizeinbytes': 4})
1317 
1318     def __delfield_serial(self): del self.__field_serial
1319 
1320     serial=property(__getfield_serial, __setfield_serial, __delfield_serial, None)
1321 
1322     def __getfield_datalen(self):
1323         return self.__field_datalen.getvalue()
1324 
1325     def __setfield_datalen(self, value):
1326         if isinstance(value,UINT):
1327             self.__field_datalen=value
1328         else:
1329             self.__field_datalen=UINT(value,**{'sizeinbytes': 2})
1330 
1331     def __delfield_datalen(self): del self.__field_datalen
1332 
1333     datalen=property(__getfield_datalen, __setfield_datalen, __delfield_datalen, None)
1334 
1335     def __getfield_data(self):
1336         return self.__field_data.getvalue()
1337 
1338     def __setfield_data(self, value):
1339         if isinstance(value,DATA):
1340             self.__field_data=value
1341         else:
1342             self.__field_data=DATA(value,**{'sizeinbytes': self.datalen})
1343 
1344     def __delfield_data(self): del self.__field_data
1345 
1346     data=property(__getfield_data, __setfield_data, __delfield_data, None)
1347 
1348     def __getfield_randomgunk(self):
1349         return self.__field_randomgunk.getvalue()
1350 
1351     def __setfield_randomgunk(self, value):
1352         if isinstance(value,UNKNOWN):
1353             self.__field_randomgunk=value
1354         else:
1355             self.__field_randomgunk=UNKNOWN(value,)
1356 
1357     def __delfield_randomgunk(self): del self.__field_randomgunk
1358 
1359     randomgunk=property(__getfield_randomgunk, __setfield_randomgunk, __delfield_randomgunk, None)
1360 
1361     def iscontainer(self):
1362         return True
1363 
1364     def containerelements(self):
1365         yield ('header', self.__field_header, None)
1366         yield ('serial', self.__field_serial, None)
1367         yield ('datalen', self.__field_datalen, None)
1368         yield ('data', self.__field_data, None)
1369         yield ('randomgunk', self.__field_randomgunk, None)
1370 
1371 
1372 
1373 
1374 class pbdeleteentryrequest(BaseProtogenClass):
1375     __fields=['header', 'serial1', 'unknown', 'serial2', 'entrynumber']
1376 
1377     def __init__(self, *args, **kwargs):
1378         dict={}
1379         # What was supplied to this function
1380         dict.update(kwargs)
1381         # Parent constructor
1382         super(pbdeleteentryrequest,self).__init__(**dict)
1383         if self.__class__ is pbdeleteentryrequest:
1384             self._update(args,dict)
1385 
1386 
1387     def getfields(self):
1388         return self.__fields
1389 
1390 
1391     def _update(self, args, kwargs):
1392         super(pbdeleteentryrequest,self)._update(args,kwargs)
1393         keys=kwargs.keys()
1394         for key in keys:
1395             if key in self.__fields:
1396                 setattr(self, key, kwargs[key])
1397                 del kwargs[key]
1398         # Were any unrecognized kwargs passed in?
1399         if __debug__:
1400             self._complainaboutunusedargs(pbdeleteentryrequest,kwargs)
1401         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1402         # Make all P fields that haven't already been constructed
1403 
1404 
1405     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1406         'Writes this packet to the supplied buffer'
1407         self._bufferstartoffset=buf.getcurrentoffset()
1408         try: self.__field_header
1409         except:
1410             self.__field_header=pbheader(**{'command': 0x05, 'flag': 0x01})
1411         self.__field_header.writetobuffer(buf)
1412         self.__field_serial1.writetobuffer(buf)
1413         try: self.__field_unknown
1414         except:
1415             self.__field_unknown=UINT(**{'sizeinbytes': 2, 'constant': 0x0000})
1416         self.__field_unknown.writetobuffer(buf)
1417         self.__field_serial2.writetobuffer(buf)
1418         self.__field_entrynumber.writetobuffer(buf)
1419         self._bufferendoffset=buf.getcurrentoffset()
1420         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1421 
1422 
1423     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1424         'Reads this packet from the supplied buffer'
1425         self._bufferstartoffset=buf.getcurrentoffset()
1426         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1427         self.__field_header=pbheader(**{'command': 0x05, 'flag': 0x01})
1428         self.__field_header.readfrombuffer(buf)
1429         self.__field_serial1=UINT(**{'sizeinbytes': 4})
1430         self.__field_serial1.readfrombuffer(buf)
1431         self.__field_unknown=UINT(**{'sizeinbytes': 2, 'constant': 0x0000})
1432         self.__field_unknown.readfrombuffer(buf)
1433         self.__field_serial2=UINT(**{'sizeinbytes': 4})
1434         self.__field_serial2.readfrombuffer(buf)
1435         self.__field_entrynumber=UINT(**{'sizeinbytes': 2})
1436         self.__field_entrynumber.readfrombuffer(buf)
1437         self._bufferendoffset=buf.getcurrentoffset()
1438 
1439 
1440     def __getfield_header(self):
1441         try: self.__field_header
1442         except:
1443             self.__field_header=pbheader(**{'command': 0x05, 'flag': 0x01})
1444         return self.__field_header.getvalue()
1445 
1446     def __setfield_header(self, value):
1447         if isinstance(value,pbheader):
1448             self.__field_header=value
1449         else:
1450             self.__field_header=pbheader(value,**{'command': 0x05, 'flag': 0x01})
1451 
1452     def __delfield_header(self): del self.__field_header
1453 
1454     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1455 
1456     def __getfield_serial1(self):
1457         return self.__field_serial1.getvalue()
1458 
1459     def __setfield_serial1(self, value):
1460         if isinstance(value,UINT):
1461             self.__field_serial1=value
1462         else:
1463             self.__field_serial1=UINT(value,**{'sizeinbytes': 4})
1464 
1465     def __delfield_serial1(self): del self.__field_serial1
1466 
1467     serial1=property(__getfield_serial1, __setfield_serial1, __delfield_serial1, None)
1468 
1469     def __getfield_unknown(self):
1470         try: self.__field_unknown
1471         except:
1472             self.__field_unknown=UINT(**{'sizeinbytes': 2, 'constant': 0x0000})
1473         return self.__field_unknown.getvalue()
1474 
1475     def __setfield_unknown(self, value):
1476         if isinstance(value,UINT):
1477             self.__field_unknown=value
1478         else:
1479             self.__field_unknown=UINT(value,**{'sizeinbytes': 2, 'constant': 0x0000})
1480 
1481     def __delfield_unknown(self): del self.__field_unknown
1482 
1483     unknown=property(__getfield_unknown, __setfield_unknown, __delfield_unknown, None)
1484 
1485     def __getfield_serial2(self):
1486         return self.__field_serial2.getvalue()
1487 
1488     def __setfield_serial2(self, value):
1489         if isinstance(value,UINT):
1490             self.__field_serial2=value
1491         else:
1492             self.__field_serial2=UINT(value,**{'sizeinbytes': 4})
1493 
1494     def __delfield_serial2(self): del self.__field_serial2
1495 
1496     serial2=property(__getfield_serial2, __setfield_serial2, __delfield_serial2, None)
1497 
1498     def __getfield_entrynumber(self):
1499         return self.__field_entrynumber.getvalue()
1500 
1501     def __setfield_entrynumber(self, value):
1502         if isinstance(value,UINT):
1503             self.__field_entrynumber=value
1504         else:
1505             self.__field_entrynumber=UINT(value,**{'sizeinbytes': 2})
1506 
1507     def __delfield_entrynumber(self): del self.__field_entrynumber
1508 
1509     entrynumber=property(__getfield_entrynumber, __setfield_entrynumber, __delfield_entrynumber, None)
1510 
1511     def iscontainer(self):
1512         return True
1513 
1514     def containerelements(self):
1515         yield ('header', self.__field_header, None)
1516         yield ('serial1', self.__field_serial1, None)
1517         yield ('unknown', self.__field_unknown, None)
1518         yield ('serial2', self.__field_serial2, None)
1519         yield ('entrynumber', self.__field_entrynumber, None)
1520 
1521 
1522 
1523 
1524 class pbdeleteentryresponse(BaseProtogenClass):
1525     __fields=['header', 'dunno']
1526 
1527     def __init__(self, *args, **kwargs):
1528         dict={}
1529         # What was supplied to this function
1530         dict.update(kwargs)
1531         # Parent constructor
1532         super(pbdeleteentryresponse,self).__init__(**dict)
1533         if self.__class__ is pbdeleteentryresponse:
1534             self._update(args,dict)
1535 
1536 
1537     def getfields(self):
1538         return self.__fields
1539 
1540 
1541     def _update(self, args, kwargs):
1542         super(pbdeleteentryresponse,self)._update(args,kwargs)
1543         keys=kwargs.keys()
1544         for key in keys:
1545             if key in self.__fields:
1546                 setattr(self, key, kwargs[key])
1547                 del kwargs[key]
1548         # Were any unrecognized kwargs passed in?
1549         if __debug__:
1550             self._complainaboutunusedargs(pbdeleteentryresponse,kwargs)
1551         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1552         # Make all P fields that haven't already been constructed
1553 
1554 
1555     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1556         'Writes this packet to the supplied buffer'
1557         self._bufferstartoffset=buf.getcurrentoffset()
1558         self.__field_header.writetobuffer(buf)
1559         self.__field_dunno.writetobuffer(buf)
1560         self._bufferendoffset=buf.getcurrentoffset()
1561         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1562 
1563 
1564     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1565         'Reads this packet from the supplied buffer'
1566         self._bufferstartoffset=buf.getcurrentoffset()
1567         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1568         self.__field_header=pbheader()
1569         self.__field_header.readfrombuffer(buf)
1570         self.__field_dunno=UNKNOWN()
1571         self.__field_dunno.readfrombuffer(buf)
1572         self._bufferendoffset=buf.getcurrentoffset()
1573 
1574 
1575     def __getfield_header(self):
1576         return self.__field_header.getvalue()
1577 
1578     def __setfield_header(self, value):
1579         if isinstance(value,pbheader):
1580             self.__field_header=value
1581         else:
1582             self.__field_header=pbheader(value,)
1583 
1584     def __delfield_header(self): del self.__field_header
1585 
1586     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1587 
1588     def __getfield_dunno(self):
1589         return self.__field_dunno.getvalue()
1590 
1591     def __setfield_dunno(self, value):
1592         if isinstance(value,UNKNOWN):
1593             self.__field_dunno=value
1594         else:
1595             self.__field_dunno=UNKNOWN(value,)
1596 
1597     def __delfield_dunno(self): del self.__field_dunno
1598 
1599     dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, None)
1600 
1601     def iscontainer(self):
1602         return True
1603 
1604     def containerelements(self):
1605         yield ('header', self.__field_header, None)
1606         yield ('dunno', self.__field_dunno, None)
1607 
1608 
1609 
1610 
1611 class pbupdateentryresponse(BaseProtogenClass):
1612     __fields=['header', 'serial1', 'dunno']
1613 
1614     def __init__(self, *args, **kwargs):
1615         dict={}
1616         # What was supplied to this function
1617         dict.update(kwargs)
1618         # Parent constructor
1619         super(pbupdateentryresponse,self).__init__(**dict)
1620         if self.__class__ is pbupdateentryresponse:
1621             self._update(args,dict)
1622 
1623 
1624     def getfields(self):
1625         return self.__fields
1626 
1627 
1628     def _update(self, args, kwargs):
1629         super(pbupdateentryresponse,self)._update(args,kwargs)
1630         keys=kwargs.keys()
1631         for key in keys:
1632             if key in self.__fields:
1633                 setattr(self, key, kwargs[key])
1634                 del kwargs[key]
1635         # Were any unrecognized kwargs passed in?
1636         if __debug__:
1637             self._complainaboutunusedargs(pbupdateentryresponse,kwargs)
1638         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1639         # Make all P fields that haven't already been constructed
1640 
1641 
1642     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1643         'Writes this packet to the supplied buffer'
1644         self._bufferstartoffset=buf.getcurrentoffset()
1645         self.__field_header.writetobuffer(buf)
1646         self.__field_serial1.writetobuffer(buf)
1647         self.__field_dunno.writetobuffer(buf)
1648         self._bufferendoffset=buf.getcurrentoffset()
1649         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1650 
1651 
1652     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1653         'Reads this packet from the supplied buffer'
1654         self._bufferstartoffset=buf.getcurrentoffset()
1655         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1656         self.__field_header=pbheader()
1657         self.__field_header.readfrombuffer(buf)
1658         self.__field_serial1=UINT(**{'sizeinbytes': 4})
1659         self.__field_serial1.readfrombuffer(buf)
1660         self.__field_dunno=UNKNOWN()
1661         self.__field_dunno.readfrombuffer(buf)
1662         self._bufferendoffset=buf.getcurrentoffset()
1663 
1664 
1665     def __getfield_header(self):
1666         return self.__field_header.getvalue()
1667 
1668     def __setfield_header(self, value):
1669         if isinstance(value,pbheader):
1670             self.__field_header=value
1671         else:
1672             self.__field_header=pbheader(value,)
1673 
1674     def __delfield_header(self): del self.__field_header
1675 
1676     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1677 
1678     def __getfield_serial1(self):
1679         return self.__field_serial1.getvalue()
1680 
1681     def __setfield_serial1(self, value):
1682         if isinstance(value,UINT):
1683             self.__field_serial1=value
1684         else:
1685             self.__field_serial1=UINT(value,**{'sizeinbytes': 4})
1686 
1687     def __delfield_serial1(self): del self.__field_serial1
1688 
1689     serial1=property(__getfield_serial1, __setfield_serial1, __delfield_serial1, None)
1690 
1691     def __getfield_dunno(self):
1692         return self.__field_dunno.getvalue()
1693 
1694     def __setfield_dunno(self, value):
1695         if isinstance(value,UNKNOWN):
1696             self.__field_dunno=value
1697         else:
1698             self.__field_dunno=UNKNOWN(value,)
1699 
1700     def __delfield_dunno(self): del self.__field_dunno
1701 
1702     dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, None)
1703 
1704     def iscontainer(self):
1705         return True
1706 
1707     def containerelements(self):
1708         yield ('header', self.__field_header, None)
1709         yield ('serial1', self.__field_serial1, None)
1710         yield ('dunno', self.__field_dunno, None)
1711 
1712 
1713 
1714 
1715 class pbappendentryresponse(BaseProtogenClass):
1716     __fields=['header', 'newserial', 'dunno', 'dunno2']
1717 
1718     def __init__(self, *args, **kwargs):
1719         dict={}
1720         # What was supplied to this function
1721         dict.update(kwargs)
1722         # Parent constructor
1723         super(pbappendentryresponse,self).__init__(**dict)
1724         if self.__class__ is pbappendentryresponse:
1725             self._update(args,dict)
1726 
1727 
1728     def getfields(self):
1729         return self.__fields
1730 
1731 
1732     def _update(self, args, kwargs):
1733         super(pbappendentryresponse,self)._update(args,kwargs)
1734         keys=kwargs.keys()
1735         for key in keys:
1736             if key in self.__fields:
1737                 setattr(self, key, kwargs[key])
1738                 del kwargs[key]
1739         # Were any unrecognized kwargs passed in?
1740         if __debug__:
1741             self._complainaboutunusedargs(pbappendentryresponse,kwargs)
1742         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1743         # Make all P fields that haven't already been constructed
1744 
1745 
1746     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1747         'Writes this packet to the supplied buffer'
1748         self._bufferstartoffset=buf.getcurrentoffset()
1749         self.__field_header.writetobuffer(buf)
1750         self.__field_newserial.writetobuffer(buf)
1751         self.__field_dunno.writetobuffer(buf)
1752         self.__field_dunno2.writetobuffer(buf)
1753         self._bufferendoffset=buf.getcurrentoffset()
1754         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1755 
1756 
1757     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1758         'Reads this packet from the supplied buffer'
1759         self._bufferstartoffset=buf.getcurrentoffset()
1760         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1761         self.__field_header=pbheader()
1762         self.__field_header.readfrombuffer(buf)
1763         self.__field_newserial=UINT(**{'sizeinbytes': 4})
1764         self.__field_newserial.readfrombuffer(buf)
1765         self.__field_dunno=UINT(**{'sizeinbytes': 2})
1766         self.__field_dunno.readfrombuffer(buf)
1767         self.__field_dunno2=UNKNOWN()
1768         self.__field_dunno2.readfrombuffer(buf)
1769         self._bufferendoffset=buf.getcurrentoffset()
1770 
1771 
1772     def __getfield_header(self):
1773         return self.__field_header.getvalue()
1774 
1775     def __setfield_header(self, value):
1776         if isinstance(value,pbheader):
1777             self.__field_header=value
1778         else:
1779             self.__field_header=pbheader(value,)
1780 
1781     def __delfield_header(self): del self.__field_header
1782 
1783     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1784 
1785     def __getfield_newserial(self):
1786         return self.__field_newserial.getvalue()
1787 
1788     def __setfield_newserial(self, value):
1789         if isinstance(value,UINT):
1790             self.__field_newserial=value
1791         else:
1792             self.__field_newserial=UINT(value,**{'sizeinbytes': 4})
1793 
1794     def __delfield_newserial(self): del self.__field_newserial
1795 
1796     newserial=property(__getfield_newserial, __setfield_newserial, __delfield_newserial, None)
1797 
1798     def __getfield_dunno(self):
1799         return self.__field_dunno.getvalue()
1800 
1801     def __setfield_dunno(self, value):
1802         if isinstance(value,UINT):
1803             self.__field_dunno=value
1804         else:
1805             self.__field_dunno=UINT(value,**{'sizeinbytes': 2})
1806 
1807     def __delfield_dunno(self): del self.__field_dunno
1808 
1809     dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, None)
1810 
1811     def __getfield_dunno2(self):
1812         return self.__field_dunno2.getvalue()
1813 
1814     def __setfield_dunno2(self, value):
1815         if isinstance(value,UNKNOWN):
1816             self.__field_dunno2=value
1817         else:
1818             self.__field_dunno2=UNKNOWN(value,)
1819 
1820     def __delfield_dunno2(self): del self.__field_dunno2
1821 
1822     dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None)
1823 
1824     def iscontainer(self):
1825         return True
1826 
1827     def containerelements(self):
1828         yield ('header', self.__field_header, None)
1829         yield ('newserial', self.__field_newserial, None)
1830         yield ('dunno', self.__field_dunno, None)
1831         yield ('dunno2', self.__field_dunno2, None)
1832 
1833 
1834 
1835 
1836 class LockKeyReq(BaseProtogenClass):
1837     __fields=['cmd', 'lock']
1838 
1839     def __init__(self, *args, **kwargs):
1840         dict={}
1841         # What was supplied to this function
1842         dict.update(kwargs)
1843         # Parent constructor
1844         super(LockKeyReq,self).__init__(**dict)
1845         if self.__class__ is LockKeyReq:
1846             self._update(args,dict)
1847 
1848 
1849     def getfields(self):
1850         return self.__fields
1851 
1852 
1853     def _update(self, args, kwargs):
1854         super(LockKeyReq,self)._update(args,kwargs)
1855         keys=kwargs.keys()
1856         for key in keys:
1857             if key in self.__fields:
1858                 setattr(self, key, kwargs[key])
1859                 del kwargs[key]
1860         # Were any unrecognized kwargs passed in?
1861         if __debug__:
1862             self._complainaboutunusedargs(LockKeyReq,kwargs)
1863         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1864         # Make all P fields that haven't already been constructed
1865 
1866 
1867     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1868         'Writes this packet to the supplied buffer'
1869         self._bufferstartoffset=buf.getcurrentoffset()
1870         try: self.__field_cmd
1871         except:
1872             self.__field_cmd=UINT(**{'sizeinbytes': 1,  'default': 0x21 })
1873         self.__field_cmd.writetobuffer(buf)
1874         try: self.__field_lock
1875         except:
1876             self.__field_lock=UINT(**{'sizeinbytes': 2,  'default': 0 })
1877         self.__field_lock.writetobuffer(buf)
1878         self._bufferendoffset=buf.getcurrentoffset()
1879         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1880 
1881 
1882     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1883         'Reads this packet from the supplied buffer'
1884         self._bufferstartoffset=buf.getcurrentoffset()
1885         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1886         self.__field_cmd=UINT(**{'sizeinbytes': 1,  'default': 0x21 })
1887         self.__field_cmd.readfrombuffer(buf)
1888         self.__field_lock=UINT(**{'sizeinbytes': 2,  'default': 0 })
1889         self.__field_lock.readfrombuffer(buf)
1890         self._bufferendoffset=buf.getcurrentoffset()
1891 
1892 
1893     def __getfield_cmd(self):
1894         try: self.__field_cmd
1895         except:
1896             self.__field_cmd=UINT(**{'sizeinbytes': 1,  'default': 0x21 })
1897         return self.__field_cmd.getvalue()
1898 
1899     def __setfield_cmd(self, value):
1900         if isinstance(value,UINT):
1901             self.__field_cmd=value
1902         else:
1903             self.__field_cmd=UINT(value,**{'sizeinbytes': 1,  'default': 0x21 })
1904 
1905     def __delfield_cmd(self): del self.__field_cmd
1906 
1907     cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None)
1908 
1909     def __getfield_lock(self):
1910         try: self.__field_lock
1911         except:
1912             self.__field_lock=UINT(**{'sizeinbytes': 2,  'default': 0 })
1913         return self.__field_lock.getvalue()
1914 
1915     def __setfield_lock(self, value):
1916         if isinstance(value,UINT):
1917             self.__field_lock=value
1918         else:
1919             self.__field_lock=UINT(value,**{'sizeinbytes': 2,  'default': 0 })
1920 
1921     def __delfield_lock(self): del self.__field_lock
1922 
1923     lock=property(__getfield_lock, __setfield_lock, __delfield_lock, "0=Lock, 1=Unlock")
1924 
1925     def iscontainer(self):
1926         return True
1927 
1928     def containerelements(self):
1929         yield ('cmd', self.__field_cmd, None)
1930         yield ('lock', self.__field_lock, "0=Lock, 1=Unlock")
1931 
1932 
1933 
1934 
1935 class KeyPressReq(BaseProtogenClass):
1936     __fields=['cmd', 'hold', 'key']
1937 
1938     def __init__(self, *args, **kwargs):
1939         dict={}
1940         # What was supplied to this function
1941         dict.update(kwargs)
1942         # Parent constructor
1943         super(KeyPressReq,self).__init__(**dict)
1944         if self.__class__ is KeyPressReq:
1945             self._update(args,dict)
1946 
1947 
1948     def getfields(self):
1949         return self.__fields
1950 
1951 
1952     def _update(self, args, kwargs):
1953         super(KeyPressReq,self)._update(args,kwargs)
1954         keys=kwargs.keys()
1955         for key in keys:
1956             if key in self.__fields:
1957                 setattr(self, key, kwargs[key])
1958                 del kwargs[key]
1959         # Were any unrecognized kwargs passed in?
1960         if __debug__:
1961             self._complainaboutunusedargs(KeyPressReq,kwargs)
1962         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1963         # Make all P fields that haven't already been constructed
1964 
1965 
1966     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1967         'Writes this packet to the supplied buffer'
1968         self._bufferstartoffset=buf.getcurrentoffset()
1969         try: self.__field_cmd
1970         except:
1971             self.__field_cmd=UINT(**{'sizeinbytes': 1,  'default': 0x20 })
1972         self.__field_cmd.writetobuffer(buf)
1973         try: self.__field_hold
1974         except:
1975             self.__field_hold=UINT(**{'sizeinbytes': 1,  'default': 0 })
1976         self.__field_hold.writetobuffer(buf)
1977         self.__field_key.writetobuffer(buf)
1978         self._bufferendoffset=buf.getcurrentoffset()
1979         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1980 
1981 
1982     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1983         'Reads this packet from the supplied buffer'
1984         self._bufferstartoffset=buf.getcurrentoffset()
1985         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1986         self.__field_cmd=UINT(**{'sizeinbytes': 1,  'default': 0x20 })
1987         self.__field_cmd.readfrombuffer(buf)
1988         self.__field_hold=UINT(**{'sizeinbytes': 1,  'default': 0 })
1989         self.__field_hold.readfrombuffer(buf)
1990         self.__field_key=STRING(**{'sizeinbytes': 1,  'terminator': None,                'sizeinbytes': 1 })
1991         self.__field_key.readfrombuffer(buf)
1992         self._bufferendoffset=buf.getcurrentoffset()
1993 
1994 
1995     def __getfield_cmd(self):
1996         try: self.__field_cmd
1997         except:
1998             self.__field_cmd=UINT(**{'sizeinbytes': 1,  'default': 0x20 })
1999         return self.__field_cmd.getvalue()
2000 
2001     def __setfield_cmd(self, value):
2002         if isinstance(value,UINT):
2003             self.__field_cmd=value
2004         else:
2005             self.__field_cmd=UINT(value,**{'sizeinbytes': 1,  'default': 0x20 })
2006 
2007     def __delfield_cmd(self): del self.__field_cmd
2008 
2009     cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None)
2010 
2011     def __getfield_hold(self):
2012         try: self.__field_hold
2013         except:
2014             self.__field_hold=UINT(**{'sizeinbytes': 1,  'default': 0 })
2015         return self.__field_hold.getvalue()
2016 
2017     def __setfield_hold(self, value):
2018         if isinstance(value,UINT):
2019             self.__field_hold=value
2020         else:
2021             self.__field_hold=UINT(value,**{'sizeinbytes': 1,  'default': 0 })
2022 
2023     def __delfield_hold(self): del self.__field_hold
2024 
2025     hold=property(__getfield_hold, __setfield_hold, __delfield_hold, None)
2026 
2027     def __getfield_key(self):
2028         return self.__field_key.getvalue()
2029 
2030     def __setfield_key(self, value):
2031         if isinstance(value,STRING):
2032             self.__field_key=value
2033         else:
2034             self.__field_key=STRING(value,**{'sizeinbytes': 1,  'terminator': None,                'sizeinbytes': 1 })
2035 
2036     def __delfield_key(self): del self.__field_key
2037 
2038     key=property(__getfield_key, __setfield_key, __delfield_key, None)
2039 
2040     def iscontainer(self):
2041         return True
2042 
2043     def containerelements(self):
2044         yield ('cmd', self.__field_cmd, None)
2045         yield ('hold', self.__field_hold, None)
2046         yield ('key', self.__field_key, None)
2047 
2048 
2049 
2050 
2051 class ULReq(BaseProtogenClass):
2052     ""
2053     __fields=['cmd', 'unlock_code', 'unlock_key', 'zero']
2054 
2055     def __init__(self, *args, **kwargs):
2056         dict={}
2057         # What was supplied to this function
2058         dict.update(kwargs)
2059         # Parent constructor
2060         super(ULReq,self).__init__(**dict)
2061         if self.__class__ is ULReq:
2062             self._update(args,dict)
2063 
2064 
2065     def getfields(self):
2066         return self.__fields
2067 
2068 
2069     def _update(self, args, kwargs):
2070         super(ULReq,self)._update(args,kwargs)
2071         keys=kwargs.keys()
2072         for key in keys:
2073             if key in self.__fields:
2074                 setattr(self, key, kwargs[key])
2075                 del kwargs[key]
2076         # Were any unrecognized kwargs passed in?
2077         if __debug__:
2078             self._complainaboutunusedargs(ULReq,kwargs)
2079         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2080         # Make all P fields that haven't already been constructed
2081 
2082 
2083     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2084         'Writes this packet to the supplied buffer'
2085         self._bufferstartoffset=buf.getcurrentoffset()
2086         try: self.__field_cmd
2087         except:
2088             self.__field_cmd=UINT(**{'sizeinbytes': 1,  'default': 0xFE })
2089         self.__field_cmd.writetobuffer(buf)
2090         try: self.__field_unlock_code
2091         except:
2092             self.__field_unlock_code=UINT(**{'sizeinbytes': 1,  'default': 0x00 })
2093         self.__field_unlock_code.writetobuffer(buf)
2094         self.__field_unlock_key.writetobuffer(buf)
2095         try: self.__field_zero
2096         except:
2097             self.__field_zero=UINT(**{'sizeinbytes': 1,  'default': 0x00 })
2098         self.__field_zero.writetobuffer(buf)
2099         self._bufferendoffset=buf.getcurrentoffset()
2100         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2101 
2102 
2103     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2104         'Reads this packet from the supplied buffer'
2105         self._bufferstartoffset=buf.getcurrentoffset()
2106         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2107         self.__field_cmd=UINT(**{'sizeinbytes': 1,  'default': 0xFE })
2108         self.__field_cmd.readfrombuffer(buf)
2109         self.__field_unlock_code=UINT(**{'sizeinbytes': 1,  'default': 0x00 })
2110         self.__field_unlock_code.readfrombuffer(buf)
2111         self.__field_unlock_key=UINT(**{'sizeinbytes': 4})
2112         self.__field_unlock_key.readfrombuffer(buf)
2113         self.__field_zero=UINT(**{'sizeinbytes': 1,  'default': 0x00 })
2114         self.__field_zero.readfrombuffer(buf)
2115         self._bufferendoffset=buf.getcurrentoffset()
2116 
2117 
2118     def __getfield_cmd(self):
2119         try: self.__field_cmd
2120         except:
2121             self.__field_cmd=UINT(**{'sizeinbytes': 1,  'default': 0xFE })
2122         return self.__field_cmd.getvalue()
2123 
2124     def __setfield_cmd(self, value):
2125         if isinstance(value,UINT):
2126             self.__field_cmd=value
2127         else:
2128             self.__field_cmd=UINT(value,**{'sizeinbytes': 1,  'default': 0xFE })
2129 
2130     def __delfield_cmd(self): del self.__field_cmd
2131 
2132     cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None)
2133 
2134     def __getfield_unlock_code(self):
2135         try: self.__field_unlock_code
2136         except:
2137             self.__field_unlock_code=UINT(**{'sizeinbytes': 1,  'default': 0x00 })
2138         return self.__field_unlock_code.getvalue()
2139 
2140     def __setfield_unlock_code(self, value):
2141         if isinstance(value,UINT):
2142             self.__field_unlock_code=value
2143         else:
2144             self.__field_unlock_code=UINT(value,**{'sizeinbytes': 1,  'default': 0x00 })
2145 
2146     def __delfield_unlock_code(self): del self.__field_unlock_code
2147 
2148     unlock_code=property(__getfield_unlock_code, __setfield_unlock_code, __delfield_unlock_code, None)
2149 
2150     def __getfield_unlock_key(self):
2151         return self.__field_unlock_key.getvalue()
2152 
2153     def __setfield_unlock_key(self, value):
2154         if isinstance(value,UINT):
2155             self.__field_unlock_key=value
2156         else:
2157             self.__field_unlock_key=UINT(value,**{'sizeinbytes': 4})
2158 
2159     def __delfield_unlock_key(self): del self.__field_unlock_key
2160 
2161     unlock_key=property(__getfield_unlock_key, __setfield_unlock_key, __delfield_unlock_key, None)
2162 
2163     def __getfield_zero(self):
2164         try: self.__field_zero
2165         except:
2166             self.__field_zero=UINT(**{'sizeinbytes': 1,  'default': 0x00 })
2167         return self.__field_zero.getvalue()
2168 
2169     def __setfield_zero(self, value):
2170         if isinstance(value,UINT):
2171             self.__field_zero=value
2172         else:
2173             self.__field_zero=UINT(value,**{'sizeinbytes': 1,  'default': 0x00 })
2174 
2175     def __delfield_zero(self): del self.__field_zero
2176 
2177     zero=property(__getfield_zero, __setfield_zero, __delfield_zero, None)
2178 
2179     def iscontainer(self):
2180         return True
2181 
2182     def containerelements(self):
2183         yield ('cmd', self.__field_cmd, None)
2184         yield ('unlock_code', self.__field_unlock_code, None)
2185         yield ('unlock_key', self.__field_unlock_key, None)
2186         yield ('zero', self.__field_zero, None)
2187 
2188 
2189 
2190 
2191 class ULRes(BaseProtogenClass):
2192     ""
2193     __fields=['cmd', 'unlock_code', 'unlock_key', 'unlock_ok']
2194 
2195     def __init__(self, *args, **kwargs):
2196         dict={}
2197         # What was supplied to this function
2198         dict.update(kwargs)
2199         # Parent constructor
2200         super(ULRes,self).__init__(**dict)
2201         if self.__class__ is ULRes:
2202             self._update(args,dict)
2203 
2204 
2205     def getfields(self):
2206         return self.__fields
2207 
2208 
2209     def _update(self, args, kwargs):
2210         super(ULRes,self)._update(args,kwargs)
2211         keys=kwargs.keys()
2212         for key in keys:
2213             if key in self.__fields:
2214                 setattr(self, key, kwargs[key])
2215                 del kwargs[key]
2216         # Were any unrecognized kwargs passed in?
2217         if __debug__:
2218             self._complainaboutunusedargs(ULRes,kwargs)
2219         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2220         # Make all P fields that haven't already been constructed
2221 
2222 
2223     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2224         'Writes this packet to the supplied buffer'
2225         self._bufferstartoffset=buf.getcurrentoffset()
2226         self.__field_cmd.writetobuffer(buf)
2227         self.__field_unlock_code.writetobuffer(buf)
2228         self.__field_unlock_key.writetobuffer(buf)
2229         self.__field_unlock_ok.writetobuffer(buf)
2230         self._bufferendoffset=buf.getcurrentoffset()
2231         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2232 
2233 
2234     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2235         'Reads this packet from the supplied buffer'
2236         self._bufferstartoffset=buf.getcurrentoffset()
2237         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2238         self.__field_cmd=UINT(**{'sizeinbytes': 1})
2239         self.__field_cmd.readfrombuffer(buf)
2240         self.__field_unlock_code=UINT(**{'sizeinbytes': 1})
2241         self.__field_unlock_code.readfrombuffer(buf)
2242         self.__field_unlock_key=UINT(**{'sizeinbytes': 4})
2243         self.__field_unlock_key.readfrombuffer(buf)
2244         self.__field_unlock_ok=UINT(**{'sizeinbytes': 1})
2245         self.__field_unlock_ok.readfrombuffer(buf)
2246         self._bufferendoffset=buf.getcurrentoffset()
2247 
2248 
2249     def __getfield_cmd(self):
2250         return self.__field_cmd.getvalue()
2251 
2252     def __setfield_cmd(self, value):
2253         if isinstance(value,UINT):
2254             self.__field_cmd=value
2255         else:
2256             self.__field_cmd=UINT(value,**{'sizeinbytes': 1})
2257 
2258     def __delfield_cmd(self): del self.__field_cmd
2259 
2260     cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None)
2261 
2262     def __getfield_unlock_code(self):
2263         return self.__field_unlock_code.getvalue()
2264 
2265     def __setfield_unlock_code(self, value):
2266         if isinstance(value,UINT):
2267             self.__field_unlock_code=value
2268         else:
2269             self.__field_unlock_code=UINT(value,**{'sizeinbytes': 1})
2270 
2271     def __delfield_unlock_code(self): del self.__field_unlock_code
2272 
2273     unlock_code=property(__getfield_unlock_code, __setfield_unlock_code, __delfield_unlock_code, None)
2274 
2275     def __getfield_unlock_key(self):
2276         return self.__field_unlock_key.getvalue()
2277 
2278     def __setfield_unlock_key(self, value):
2279         if isinstance(value,UINT):
2280             self.__field_unlock_key=value
2281         else:
2282             self.__field_unlock_key=UINT(value,**{'sizeinbytes': 4})
2283 
2284     def __delfield_unlock_key(self): del self.__field_unlock_key
2285 
2286     unlock_key=property(__getfield_unlock_key, __setfield_unlock_key, __delfield_unlock_key, None)
2287 
2288     def __getfield_unlock_ok(self):
2289         return self.__field_unlock_ok.getvalue()
2290 
2291     def __setfield_unlock_ok(self, value):
2292         if isinstance(value,UINT):
2293             self.__field_unlock_ok=value
2294         else:
2295             self.__field_unlock_ok=UINT(value,**{'sizeinbytes': 1})
2296 
2297     def __delfield_unlock_ok(self): del self.__field_unlock_ok
2298 
2299     unlock_ok=property(__getfield_unlock_ok, __setfield_unlock_ok, __delfield_unlock_ok, None)
2300 
2301     def iscontainer(self):
2302         return True
2303 
2304     def containerelements(self):
2305         yield ('cmd', self.__field_cmd, None)
2306         yield ('unlock_code', self.__field_unlock_code, None)
2307         yield ('unlock_key', self.__field_unlock_key, None)
2308         yield ('unlock_ok', self.__field_unlock_ok, None)
2309 
2310 
2311 
2312 
2313 class DMKeyReq(BaseProtogenClass):
2314     "Slightly different command for DMv6"
2315     __fields=['cmd', 'unlock_code', 'unlock_key', 'zero', 'option']
2316 
2317     def __init__(self, *args, **kwargs):
2318         dict={}
2319         # What was supplied to this function
2320         dict.update(kwargs)
2321         # Parent constructor
2322         super(DMKeyReq,self).__init__(**dict)
2323         if self.__class__ is DMKeyReq:
2324             self._update(args,dict)
2325 
2326 
2327     def getfields(self):
2328         return self.__fields
2329 
2330 
2331     def _update(self, args, kwargs):
2332         super(DMKeyReq,self)._update(args,kwargs)
2333         keys=kwargs.keys()
2334         for key in keys:
2335             if key in self.__fields:
2336                 setattr(self, key, kwargs[key])
2337                 del kwargs[key]
2338         # Were any unrecognized kwargs passed in?
2339         if __debug__:
2340             self._complainaboutunusedargs(DMKeyReq,kwargs)
2341         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2342         # Make all P fields that haven't already been constructed
2343 
2344 
2345     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2346         'Writes this packet to the supplied buffer'
2347         self._bufferstartoffset=buf.getcurrentoffset()
2348         try: self.__field_cmd
2349         except:
2350             self.__field_cmd=UINT(**{'sizeinbytes': 1,  'default': 0xFE })
2351         self.__field_cmd.writetobuffer(buf)
2352         try: self.__field_unlock_code
2353         except:
2354             self.__field_unlock_code=UINT(**{'sizeinbytes': 1,  'default': 0x00 })
2355         self.__field_unlock_code.writetobuffer(buf)
2356         try: self.__field_unlock_key
2357         except:
2358             self.__field_unlock_key=UINT(**{'sizeinbytes': 4,  'default': 0x00 })
2359         self.__field_unlock_key.writetobuffer(buf)
2360         try: self.__field_zero
2361         except:
2362             self.__field_zero=UINT(**{'sizeinbytes': 1,  'default': 0x00 })
2363         self.__field_zero.writetobuffer(buf)
2364         try: self.__field_option
2365         except:
2366             self.__field_option=UINT(**{'sizeinbytes': 1,  'default': 0x00 })
2367         self.__field_option.writetobuffer(buf)
2368         self._bufferendoffset=buf.getcurrentoffset()
2369         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2370 
2371 
2372     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2373         'Reads this packet from the supplied buffer'
2374         self._bufferstartoffset=buf.getcurrentoffset()
2375         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2376         self.__field_cmd=UINT(**{'sizeinbytes': 1,  'default': 0xFE })
2377         self.__field_cmd.readfrombuffer(buf)
2378         self.__field_unlock_code=UINT(**{'sizeinbytes': 1,  'default': 0x00 })
2379         self.__field_unlock_code.readfrombuffer(buf)
2380         self.__field_unlock_key=UINT(**{'sizeinbytes': 4,  'default': 0x00 })
2381         self.__field_unlock_key.readfrombuffer(buf)
2382         self.__field_zero=UINT(**{'sizeinbytes': 1,  'default': 0x00 })
2383         self.__field_zero.readfrombuffer(buf)
2384         self.__field_option=UINT(**{'sizeinbytes': 1,  'default': 0x00 })
2385         self.__field_option.readfrombuffer(buf)
2386         self._bufferendoffset=buf.getcurrentoffset()
2387 
2388 
2389     def __getfield_cmd(self):
2390         try: self.__field_cmd
2391         except:
2392             self.__field_cmd=UINT(**{'sizeinbytes': 1,  'default': 0xFE })
2393         return self.__field_cmd.getvalue()
2394 
2395     def __setfield_cmd(self, value):
2396         if isinstance(value,UINT):
2397             self.__field_cmd=value
2398         else:
2399             self.__field_cmd=UINT(value,**{'sizeinbytes': 1,  'default': 0xFE })
2400 
2401     def __delfield_cmd(self): del self.__field_cmd
2402 
2403     cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None)
2404 
2405     def __getfield_unlock_code(self):
2406         try: self.__field_unlock_code
2407         except:
2408             self.__field_unlock_code=UINT(**{'sizeinbytes': 1,  'default': 0x00 })
2409         return self.__field_unlock_code.getvalue()
2410 
2411     def __setfield_unlock_code(self, value):
2412         if isinstance(value,UINT):
2413             self.__field_unlock_code=value
2414         else:
2415             self.__field_unlock_code=UINT(value,**{'sizeinbytes': 1,  'default': 0x00 })
2416 
2417     def __delfield_unlock_code(self): del self.__field_unlock_code
2418 
2419     unlock_code=property(__getfield_unlock_code, __setfield_unlock_code, __delfield_unlock_code, None)
2420 
2421     def __getfield_unlock_key(self):
2422         try: self.__field_unlock_key
2423         except:
2424             self.__field_unlock_key=UINT(**{'sizeinbytes': 4,  'default': 0x00 })
2425         return self.__field_unlock_key.getvalue()
2426 
2427     def __setfield_unlock_key(self, value):
2428         if isinstance(value,UINT):
2429             self.__field_unlock_key=value
2430         else:
2431             self.__field_unlock_key=UINT(value,**{'sizeinbytes': 4,  'default': 0x00 })
2432 
2433     def __delfield_unlock_key(self): del self.__field_unlock_key
2434 
2435     unlock_key=property(__getfield_unlock_key, __setfield_unlock_key, __delfield_unlock_key, None)
2436 
2437     def __getfield_zero(self):
2438         try: self.__field_zero
2439         except:
2440             self.__field_zero=UINT(**{'sizeinbytes': 1,  'default': 0x00 })
2441         return self.__field_zero.getvalue()
2442 
2443     def __setfield_zero(self, value):
2444         if isinstance(value,UINT):
2445             self.__field_zero=value
2446         else:
2447             self.__field_zero=UINT(value,**{'sizeinbytes': 1,  'default': 0x00 })
2448 
2449     def __delfield_zero(self): del self.__field_zero
2450 
2451     zero=property(__getfield_zero, __setfield_zero, __delfield_zero, None)
2452 
2453     def __getfield_option(self):
2454         try: self.__field_option
2455         except:
2456             self.__field_option=UINT(**{'sizeinbytes': 1,  'default': 0x00 })
2457         return self.__field_option.getvalue()
2458 
2459     def __setfield_option(self, value):
2460         if isinstance(value,UINT):
2461             self.__field_option=value
2462         else:
2463             self.__field_option=UINT(value,**{'sizeinbytes': 1,  'default': 0x00 })
2464 
2465     def __delfield_option(self): del self.__field_option
2466 
2467     option=property(__getfield_option, __setfield_option, __delfield_option, None)
2468 
2469     def iscontainer(self):
2470         return True
2471 
2472     def containerelements(self):
2473         yield ('cmd', self.__field_cmd, None)
2474         yield ('unlock_code', self.__field_unlock_code, None)
2475         yield ('unlock_key', self.__field_unlock_key, None)
2476         yield ('zero', self.__field_zero, None)
2477         yield ('option', self.__field_option, None)
2478 
2479 
2480 
2481 
2482 class DMKeyResp(BaseProtogenClass):
2483     "Return the key/seed needed to transition to DMv6"
2484     __fields=['cmd', 'unlock_code', 'unlock_key']
2485 
2486     def __init__(self, *args, **kwargs):
2487         dict={}
2488         # What was supplied to this function
2489         dict.update(kwargs)
2490         # Parent constructor
2491         super(DMKeyResp,self).__init__(**dict)
2492         if self.__class__ is DMKeyResp:
2493             self._update(args,dict)
2494 
2495 
2496     def getfields(self):
2497         return self.__fields
2498 
2499 
2500     def _update(self, args, kwargs):
2501         super(DMKeyResp,self)._update(args,kwargs)
2502         keys=kwargs.keys()
2503         for key in keys:
2504             if key in self.__fields:
2505                 setattr(self, key, kwargs[key])
2506                 del kwargs[key]
2507         # Were any unrecognized kwargs passed in?
2508         if __debug__:
2509             self._complainaboutunusedargs(DMKeyResp,kwargs)
2510         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2511         # Make all P fields that haven't already been constructed
2512 
2513 
2514     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2515         'Writes this packet to the supplied buffer'
2516         self._bufferstartoffset=buf.getcurrentoffset()
2517         self.__field_cmd.writetobuffer(buf)
2518         self.__field_unlock_code.writetobuffer(buf)
2519         self.__field_unlock_key.writetobuffer(buf)
2520         self._bufferendoffset=buf.getcurrentoffset()
2521         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2522 
2523 
2524     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2525         'Reads this packet from the supplied buffer'
2526         self._bufferstartoffset=buf.getcurrentoffset()
2527         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2528         self.__field_cmd=UINT(**{'sizeinbytes': 1})
2529         self.__field_cmd.readfrombuffer(buf)
2530         self.__field_unlock_code=UINT(**{'sizeinbytes': 1})
2531         self.__field_unlock_code.readfrombuffer(buf)
2532         self.__field_unlock_key=UINT(**{'sizeinbytes': 4})
2533         self.__field_unlock_key.readfrombuffer(buf)
2534         self._bufferendoffset=buf.getcurrentoffset()
2535 
2536 
2537     def __getfield_cmd(self):
2538         return self.__field_cmd.getvalue()
2539 
2540     def __setfield_cmd(self, value):
2541         if isinstance(value,UINT):
2542             self.__field_cmd=value
2543         else:
2544             self.__field_cmd=UINT(value,**{'sizeinbytes': 1})
2545 
2546     def __delfield_cmd(self): del self.__field_cmd
2547 
2548     cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None)
2549 
2550     def __getfield_unlock_code(self):
2551         return self.__field_unlock_code.getvalue()
2552 
2553     def __setfield_unlock_code(self, value):
2554         if isinstance(value,UINT):
2555             self.__field_unlock_code=value
2556         else:
2557             self.__field_unlock_code=UINT(value,**{'sizeinbytes': 1})
2558 
2559     def __delfield_unlock_code(self): del self.__field_unlock_code
2560 
2561     unlock_code=property(__getfield_unlock_code, __setfield_unlock_code, __delfield_unlock_code, None)
2562 
2563     def __getfield_unlock_key(self):
2564         return self.__field_unlock_key.getvalue()
2565 
2566     def __setfield_unlock_key(self, value):
2567         if isinstance(value,UINT):
2568             self.__field_unlock_key=value
2569         else:
2570             self.__field_unlock_key=UINT(value,**{'sizeinbytes': 4})
2571 
2572     def __delfield_unlock_key(self): del self.__field_unlock_key
2573 
2574     unlock_key=property(__getfield_unlock_key, __setfield_unlock_key, __delfield_unlock_key, None)
2575 
2576     def iscontainer(self):
2577         return True
2578 
2579     def containerelements(self):
2580         yield ('cmd', self.__field_cmd, None)
2581         yield ('unlock_code', self.__field_unlock_code, None)
2582         yield ('unlock_key', self.__field_unlock_key, None)
2583 
2584 
2585 
2586 
2587 class DMEnterReq(BaseProtogenClass):
2588     "Request to transition to DMv6"
2589     __fields=['cmd', 'unlock_code', 'unlock_key', 'zero', 'option', 'unlock_key2']
2590 
2591     def __init__(self, *args, **kwargs):
2592         dict={}
2593         # What was supplied to this function
2594         dict.update(kwargs)
2595         # Parent constructor
2596         super(DMEnterReq,self).__init__(**dict)
2597         if self.__class__ is DMEnterReq:
2598             self._update(args,dict)
2599 
2600 
2601     def getfields(self):
2602         return self.__fields
2603 
2604 
2605     def _update(self, args, kwargs):
2606         super(DMEnterReq,self)._update(args,kwargs)
2607         keys=kwargs.keys()
2608         for key in keys:
2609             if key in self.__fields:
2610                 setattr(self, key, kwargs[key])
2611                 del kwargs[key]
2612         # Were any unrecognized kwargs passed in?
2613         if __debug__:
2614             self._complainaboutunusedargs(DMEnterReq,kwargs)
2615         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2616         # Make all P fields that haven't already been constructed
2617 
2618 
2619     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2620         'Writes this packet to the supplied buffer'
2621         self._bufferstartoffset=buf.getcurrentoffset()
2622         try: self.__field_cmd
2623         except:
2624             self.__field_cmd=UINT(**{'sizeinbytes': 1,  'default': 0xFE })
2625         self.__field_cmd.writetobuffer(buf)
2626         try: self.__field_unlock_code
2627         except:
2628             self.__field_unlock_code=UINT(**{'sizeinbytes': 1,  'default': 0x00 })
2629         self.__field_unlock_code.writetobuffer(buf)
2630         try: self.__field_unlock_key
2631         except:
2632             self.__field_unlock_key=UINT(**{'sizeinbytes': 4,  'default': 0x00 })
2633         self.__field_unlock_key.writetobuffer(buf)
2634         try: self.__field_zero
2635         except:
2636             self.__field_zero=UINT(**{'sizeinbytes': 1,  'default': 0x00 })
2637         self.__field_zero.writetobuffer(buf)
2638         try: self.__field_option
2639         except:
2640             self.__field_option=UINT(**{'sizeinbytes': 1,  'default': 0x00 })
2641         self.__field_option.writetobuffer(buf)
2642         if self.unlock_code==3:
2643             try: self.__field_unlock_key2
2644             except:
2645                 self.__field_unlock_key2=LIST(**{'elementclass': _gen_p_lg_180,  'createdefault': True,                 'length': 16 })
2646             self.__field_unlock_key2.writetobuffer(buf)
2647         self._bufferendoffset=buf.getcurrentoffset()
2648         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2649 
2650 
2651     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2652         'Reads this packet from the supplied buffer'
2653         self._bufferstartoffset=buf.getcurrentoffset()
2654         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2655         self.__field_cmd=UINT(**{'sizeinbytes': 1,  'default': 0xFE })
2656         self.__field_cmd.readfrombuffer(buf)
2657         self.__field_unlock_code=UINT(**{'sizeinbytes': 1,  'default': 0x00 })
2658         self.__field_unlock_code.readfrombuffer(buf)
2659         self.__field_unlock_key=UINT(**{'sizeinbytes': 4,  'default': 0x00 })
2660         self.__field_unlock_key.readfrombuffer(buf)
2661         self.__field_zero=UINT(**{'sizeinbytes': 1,  'default': 0x00 })
2662         self.__field_zero.readfrombuffer(buf)
2663         self.__field_option=UINT(**{'sizeinbytes': 1,  'default': 0x00 })
2664         self.__field_option.readfrombuffer(buf)
2665         if self.unlock_code==3:
2666             self.__field_unlock_key2=LIST(**{'elementclass': _gen_p_lg_180,  'createdefault': True,                 'length': 16 })
2667             self.__field_unlock_key2.readfrombuffer(buf)
2668         self._bufferendoffset=buf.getcurrentoffset()
2669 
2670 
2671     def __getfield_cmd(self):
2672         try: self.__field_cmd
2673         except:
2674             self.__field_cmd=UINT(**{'sizeinbytes': 1,  'default': 0xFE })
2675         return self.__field_cmd.getvalue()
2676 
2677     def __setfield_cmd(self, value):
2678         if isinstance(value,UINT):
2679             self.__field_cmd=value
2680         else:
2681             self.__field_cmd=UINT(value,**{'sizeinbytes': 1,  'default': 0xFE })
2682 
2683     def __delfield_cmd(self): del self.__field_cmd
2684 
2685     cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None)
2686 
2687     def __getfield_unlock_code(self):
2688         try: self.__field_unlock_code
2689         except:
2690             self.__field_unlock_code=UINT(**{'sizeinbytes': 1,  'default': 0x00 })
2691         return self.__field_unlock_code.getvalue()
2692 
2693     def __setfield_unlock_code(self, value):
2694         if isinstance(value,UINT):
2695             self.__field_unlock_code=value
2696         else:
2697             self.__field_unlock_code=UINT(value,**{'sizeinbytes': 1,  'default': 0x00 })
2698 
2699     def __delfield_unlock_code(self): del self.__field_unlock_code
2700 
2701     unlock_code=property(__getfield_unlock_code, __setfield_unlock_code, __delfield_unlock_code, None)
2702 
2703     def __getfield_unlock_key(self):
2704         try: self.__field_unlock_key
2705         except:
2706             self.__field_unlock_key=UINT(**{'sizeinbytes': 4,  'default': 0x00 })
2707         return self.__field_unlock_key.getvalue()
2708 
2709     def __setfield_unlock_key(self, value):
2710         if isinstance(value,UINT):
2711             self.__field_unlock_key=value
2712         else:
2713             self.__field_unlock_key=UINT(value,**{'sizeinbytes': 4,  'default': 0x00 })
2714 
2715     def __delfield_unlock_key(self): del self.__field_unlock_key
2716 
2717     unlock_key=property(__getfield_unlock_key, __setfield_unlock_key, __delfield_unlock_key, None)
2718 
2719     def __getfield_zero(self):
2720         try: self.__field_zero
2721         except:
2722             self.__field_zero=UINT(**{'sizeinbytes': 1,  'default': 0x00 })
2723         return self.__field_zero.getvalue()
2724 
2725     def __setfield_zero(self, value):
2726         if isinstance(value,UINT):
2727             self.__field_zero=value
2728         else:
2729             self.__field_zero=UINT(value,**{'sizeinbytes': 1,  'default': 0x00 })
2730 
2731     def __delfield_zero(self): del self.__field_zero
2732 
2733     zero=property(__getfield_zero, __setfield_zero, __delfield_zero, None)
2734 
2735     def __getfield_option(self):
2736         try: self.__field_option
2737         except:
2738             self.__field_option=UINT(**{'sizeinbytes': 1,  'default': 0x00 })
2739         return self.__field_option.getvalue()
2740 
2741     def __setfield_option(self, value):
2742         if isinstance(value,UINT):
2743             self.__field_option=value
2744         else:
2745             self.__field_option=UINT(value,**{'sizeinbytes': 1,  'default': 0x00 })
2746 
2747     def __delfield_option(self): del self.__field_option
2748 
2749     option=property(__getfield_option, __setfield_option, __delfield_option, None)
2750 
2751     def __getfield_unlock_key2(self):
2752         try: self.__field_unlock_key2
2753         except:
2754             self.__field_unlock_key2=LIST(**{'elementclass': _gen_p_lg_180,  'createdefault': True,                 'length': 16 })
2755         return self.__field_unlock_key2.getvalue()
2756 
2757     def __setfield_unlock_key2(self, value):
2758         if isinstance(value,LIST):
2759             self.__field_unlock_key2=value
2760         else:
2761             self.__field_unlock_key2=LIST(value,**{'elementclass': _gen_p_lg_180,  'createdefault': True,                 'length': 16 })
2762 
2763     def __delfield_unlock_key2(self): del self.__field_unlock_key2
2764 
2765     unlock_key2=property(__getfield_unlock_key2, __setfield_unlock_key2, __delfield_unlock_key2, None)
2766 
2767     def iscontainer(self):
2768         return True
2769 
2770     def containerelements(self):
2771         yield ('cmd', self.__field_cmd, None)
2772         yield ('unlock_code', self.__field_unlock_code, None)
2773         yield ('unlock_key', self.__field_unlock_key, None)
2774         yield ('zero', self.__field_zero, None)
2775         yield ('option', self.__field_option, None)
2776         if self.unlock_code==3:
2777             yield ('unlock_key2', self.__field_unlock_key2, None)
2778 
2779 
2780     def init_key2(self):
2781         if self.unlock_code==3 and \
2782            not len(self.unlock_key2):
2783             for _idx in range(16):
2784                 self.unlock_key2.append(0)
2785 
2786     def convert_to_key2(self,shift):  
2787         """Convert the key value to key2"""
2788         if self.unlock_code!=3:
2789             return
2790         self.init_key2()
2791         _buf=buffer()
2792         UINT(sizeinbytes=4, value=~self.unlock_key).writetobuffer(_buf)
2793         _key=_buf.getvalue()
2794         for _idx in range(4):
2795             _nth_key=ord(_key[(_idx + 4 - shift) % 4])
2796             for _idy in range(4):
2797                 self.unlock_key2[_idx*4+_idy]=_nth_key
2798 
2799 
2800 
2801 
2802 
2803 class _gen_p_lg_180(BaseProtogenClass):
2804     'Anonymous inner class'
2805     __fields=['data']
2806 
2807     def __init__(self, *args, **kwargs):
2808         dict={}
2809         # What was supplied to this function
2810         dict.update(kwargs)
2811         # Parent constructor
2812         super(_gen_p_lg_180,self).__init__(**dict)
2813         if self.__class__ is _gen_p_lg_180:
2814             self._update(args,dict)
2815 
2816 
2817     def getfields(self):
2818         return self.__fields
2819 
2820 
2821     def _update(self, args, kwargs):
2822         super(_gen_p_lg_180,self)._update(args,kwargs)
2823         keys=kwargs.keys()
2824         for key in keys:
2825             if key in self.__fields:
2826                 setattr(self, key, kwargs[key])
2827                 del kwargs[key]
2828         # Were any unrecognized kwargs passed in?
2829         if __debug__:
2830             self._complainaboutunusedargs(_gen_p_lg_180,kwargs)
2831         if len(args):
2832             dict2={'sizeinbytes': 1,  'default': 0 }
2833             dict2.update(kwargs)
2834             kwargs=dict2
2835             self.__field_data=UINT(*args,**dict2)
2836         # Make all P fields that haven't already been constructed
2837 
2838 
2839     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2840         'Writes this packet to the supplied buffer'
2841         self._bufferstartoffset=buf.getcurrentoffset()
2842         try: self.__field_data
2843         except:
2844             self.__field_data=UINT(**{'sizeinbytes': 1,  'default': 0 })
2845         self.__field_data.writetobuffer(buf)
2846         self._bufferendoffset=buf.getcurrentoffset()
2847         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2848 
2849 
2850     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2851         'Reads this packet from the supplied buffer'
2852         self._bufferstartoffset=buf.getcurrentoffset()
2853         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2854         self.__field_data=UINT(**{'sizeinbytes': 1,  'default': 0 })
2855         self.__field_data.readfrombuffer(buf)
2856         self._bufferendoffset=buf.getcurrentoffset()
2857 
2858 
2859     def __getfield_data(self):
2860         try: self.__field_data
2861         except:
2862             self.__field_data=UINT(**{'sizeinbytes': 1,  'default': 0 })
2863         return self.__field_data.getvalue()
2864 
2865     def __setfield_data(self, value):
2866         if isinstance(value,UINT):
2867             self.__field_data=value
2868         else:
2869             self.__field_data=UINT(value,**{'sizeinbytes': 1,  'default': 0 })
2870 
2871     def __delfield_data(self): del self.__field_data
2872 
2873     data=property(__getfield_data, __setfield_data, __delfield_data, None)
2874 
2875     def iscontainer(self):
2876         return True
2877 
2878     def containerelements(self):
2879         yield ('data', self.__field_data, None)
2880 
2881 
2882 
2883 
2884 class DMEnterResp(BaseProtogenClass):
2885     "Response to our request to enter DMv6"
2886     __fields=['cmd', 'unlock_code', 'unlock_key', 'result']
2887 
2888     def __init__(self, *args, **kwargs):
2889         dict={}
2890         # What was supplied to this function
2891         dict.update(kwargs)
2892         # Parent constructor
2893         super(DMEnterResp,self).__init__(**dict)
2894         if self.__class__ is DMEnterResp:
2895             self._update(args,dict)
2896 
2897 
2898     def getfields(self):
2899         return self.__fields
2900 
2901 
2902     def _update(self, args, kwargs):
2903         super(DMEnterResp,self)._update(args,kwargs)
2904         keys=kwargs.keys()
2905         for key in keys:
2906             if key in self.__fields:
2907                 setattr(self, key, kwargs[key])
2908                 del kwargs[key]
2909         # Were any unrecognized kwargs passed in?
2910         if __debug__:
2911             self._complainaboutunusedargs(DMEnterResp,kwargs)
2912         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2913         # Make all P fields that haven't already been constructed
2914 
2915 
2916     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2917         'Writes this packet to the supplied buffer'
2918         self._bufferstartoffset=buf.getcurrentoffset()
2919         self.__field_cmd.writetobuffer(buf)
2920         self.__field_unlock_code.writetobuffer(buf)
2921         self.__field_unlock_key.writetobuffer(buf)
2922         self.__field_result.writetobuffer(buf)
2923         self._bufferendoffset=buf.getcurrentoffset()
2924         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2925 
2926 
2927     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2928         'Reads this packet from the supplied buffer'
2929         self._bufferstartoffset=buf.getcurrentoffset()
2930         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2931         self.__field_cmd=UINT(**{'sizeinbytes': 1})
2932         self.__field_cmd.readfrombuffer(buf)
2933         self.__field_unlock_code=UINT(**{'sizeinbytes': 1})
2934         self.__field_unlock_code.readfrombuffer(buf)
2935         self.__field_unlock_key=UINT(**{'sizeinbytes': 4})
2936         self.__field_unlock_key.readfrombuffer(buf)
2937         self.__field_result=UINT(**{'sizeinbytes': 1})
2938         self.__field_result.readfrombuffer(buf)
2939         self._bufferendoffset=buf.getcurrentoffset()
2940 
2941 
2942     def __getfield_cmd(self):
2943         return self.__field_cmd.getvalue()
2944 
2945     def __setfield_cmd(self, value):
2946         if isinstance(value,UINT):
2947             self.__field_cmd=value
2948         else:
2949             self.__field_cmd=UINT(value,**{'sizeinbytes': 1})
2950 
2951     def __delfield_cmd(self): del self.__field_cmd
2952 
2953     cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None)
2954 
2955     def __getfield_unlock_code(self):
2956         return self.__field_unlock_code.getvalue()
2957 
2958     def __setfield_unlock_code(self, value):
2959         if isinstance(value,UINT):
2960             self.__field_unlock_code=value
2961         else:
2962             self.__field_unlock_code=UINT(value,**{'sizeinbytes': 1})
2963 
2964     def __delfield_unlock_code(self): del self.__field_unlock_code
2965 
2966     unlock_code=property(__getfield_unlock_code, __setfield_unlock_code, __delfield_unlock_code, None)
2967 
2968     def __getfield_unlock_key(self):
2969         return self.__field_unlock_key.getvalue()
2970 
2971     def __setfield_unlock_key(self, value):
2972         if isinstance(value,UINT):
2973             self.__field_unlock_key=value
2974         else:
2975             self.__field_unlock_key=UINT(value,**{'sizeinbytes': 4})
2976 
2977     def __delfield_unlock_key(self): del self.__field_unlock_key
2978 
2979     unlock_key=property(__getfield_unlock_key, __setfield_unlock_key, __delfield_unlock_key, None)
2980 
2981     def __getfield_result(self):
2982         return self.__field_result.getvalue()
2983 
2984     def __setfield_result(self, value):
2985         if isinstance(value,UINT):
2986             self.__field_result=value
2987         else:
2988             self.__field_result=UINT(value,**{'sizeinbytes': 1})
2989 
2990     def __delfield_result(self): del self.__field_result
2991 
2992     result=property(__getfield_result, __setfield_result, __delfield_result, "0=Failure, 1=Success")
2993 
2994     def iscontainer(self):
2995         return True
2996 
2997     def containerelements(self):
2998         yield ('cmd', self.__field_cmd, None)
2999         yield ('unlock_code', self.__field_unlock_code, None)
3000         yield ('unlock_key', self.__field_unlock_key, None)
3001         yield ('result', self.__field_result, "0=Failure, 1=Success")
3002 
3003 
3004 
3005 
3006 class NVReq(BaseProtogenClass):
3007     __fields=['cmd', 'field', 'data']
3008 
3009     def __init__(self, *args, **kwargs):
3010         dict={}
3011         # What was supplied to this function
3012         dict.update(kwargs)
3013         # Parent constructor
3014         super(NVReq,self).__init__(**dict)
3015         if self.__class__ is NVReq:
3016             self._update(args,dict)
3017 
3018 
3019     def getfields(self):
3020         return self.__fields
3021 
3022 
3023     def _update(self, args, kwargs):
3024         super(NVReq,self)._update(args,kwargs)
3025         keys=kwargs.keys()
3026         for key in keys:
3027             if key in self.__fields:
3028                 setattr(self, key, kwargs[key])
3029                 del kwargs[key]
3030         # Were any unrecognized kwargs passed in?
3031         if __debug__:
3032             self._complainaboutunusedargs(NVReq,kwargs)
3033         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3034         # Make all P fields that haven't already been constructed
3035 
3036 
3037     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3038         'Writes this packet to the supplied buffer'
3039         self._bufferstartoffset=buf.getcurrentoffset()
3040         try: self.__field_cmd
3041         except:
3042             self.__field_cmd=UINT(**{'sizeinbytes': 1,  'constant': 0x26 })
3043         self.__field_cmd.writetobuffer(buf)
3044         self.__field_field.writetobuffer(buf)
3045         try: self.__field_data
3046         except:
3047             self.__field_data=DATA(**{'sizeinbytes': 130,  'default': '\x00'*130 })
3048         self.__field_data.writetobuffer(buf)
3049         self._bufferendoffset=buf.getcurrentoffset()
3050         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3051 
3052 
3053     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3054         'Reads this packet from the supplied buffer'
3055         self._bufferstartoffset=buf.getcurrentoffset()
3056         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3057         self.__field_cmd=UINT(**{'sizeinbytes': 1,  'constant': 0x26 })
3058         self.__field_cmd.readfrombuffer(buf)
3059         self.__field_field=UINT(**{'sizeinbytes': 2})
3060         self.__field_field.readfrombuffer(buf)
3061         self.__field_data=DATA(**{'sizeinbytes': 130,  'default': '\x00'*130 })
3062         self.__field_data.readfrombuffer(buf)
3063         self._bufferendoffset=buf.getcurrentoffset()
3064 
3065 
3066     def __getfield_cmd(self):
3067         try: self.__field_cmd
3068         except:
3069             self.__field_cmd=UINT(**{'sizeinbytes': 1,  'constant': 0x26 })
3070         return self.__field_cmd.getvalue()
3071 
3072     def __setfield_cmd(self, value):
3073         if isinstance(value,UINT):
3074             self.__field_cmd=value
3075         else:
3076             self.__field_cmd=UINT(value,**{'sizeinbytes': 1,  'constant': 0x26 })
3077 
3078     def __delfield_cmd(self): del self.__field_cmd
3079 
3080     cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None)
3081 
3082     def __getfield_field(self):
3083         return self.__field_field.getvalue()
3084 
3085     def __setfield_field(self, value):
3086         if isinstance(value,UINT):
3087             self.__field_field=value
3088         else:
3089             self.__field_field=UINT(value,**{'sizeinbytes': 2})
3090 
3091     def __delfield_field(self): del self.__field_field
3092 
3093     field=property(__getfield_field, __setfield_field, __delfield_field, None)
3094 
3095     def __getfield_data(self):
3096         try: self.__field_data
3097         except:
3098             self.__field_data=DATA(**{'sizeinbytes': 130,  'default': '\x00'*130 })
3099         return self.__field_data.getvalue()
3100 
3101     def __setfield_data(self, value):
3102         if isinstance(value,DATA):
3103             self.__field_data=value
3104         else:
3105             self.__field_data=DATA(value,**{'sizeinbytes': 130,  'default': '\x00'*130 })
3106 
3107     def __delfield_data(self): del self.__field_data
3108 
3109     data=property(__getfield_data, __setfield_data, __delfield_data, None)
3110 
3111     def iscontainer(self):
3112         return True
3113 
3114     def containerelements(self):
3115         yield ('cmd', self.__field_cmd, None)
3116         yield ('field', self.__field_field, None)
3117         yield ('data', self.__field_data, None)
3118 
3119 
3120 
3121 
3122 class NVRes(BaseProtogenClass):
3123     __fields=['cmd', 'field', 'data']
3124 
3125     def __init__(self, *args, **kwargs):
3126         dict={}
3127         # What was supplied to this function
3128         dict.update(kwargs)
3129         # Parent constructor
3130         super(NVRes,self).__init__(**dict)
3131         if self.__class__ is NVRes:
3132             self._update(args,dict)
3133 
3134 
3135     def getfields(self):
3136         return self.__fields
3137 
3138 
3139     def _update(self, args, kwargs):
3140         super(NVRes,self)._update(args,kwargs)
3141         keys=kwargs.keys()
3142         for key in keys:
3143             if key in self.__fields:
3144                 setattr(self, key, kwargs[key])
3145                 del kwargs[key]
3146         # Were any unrecognized kwargs passed in?
3147         if __debug__:
3148             self._complainaboutunusedargs(NVRes,kwargs)
3149         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3150         # Make all P fields that haven't already been constructed
3151 
3152 
3153     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3154         'Writes this packet to the supplied buffer'
3155         self._bufferstartoffset=buf.getcurrentoffset()
3156         self.__field_cmd.writetobuffer(buf)
3157         self.__field_field.writetobuffer(buf)
3158         self.__field_data.writetobuffer(buf)
3159         self._bufferendoffset=buf.getcurrentoffset()
3160         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3161 
3162 
3163     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3164         'Reads this packet from the supplied buffer'
3165         self._bufferstartoffset=buf.getcurrentoffset()
3166         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3167         self.__field_cmd=UINT(**{'sizeinbytes': 1,  'constant': 0x26 })
3168         self.__field_cmd.readfrombuffer(buf)
3169         self.__field_field=UINT(**{'sizeinbytes': 2})
3170         self.__field_field.readfrombuffer(buf)
3171         self.__field_data=DATA(**{'sizeinbytes': 130})
3172         self.__field_data.readfrombuffer(buf)
3173         self._bufferendoffset=buf.getcurrentoffset()
3174 
3175 
3176     def __getfield_cmd(self):
3177         return self.__field_cmd.getvalue()
3178 
3179     def __setfield_cmd(self, value):
3180         if isinstance(value,UINT):
3181             self.__field_cmd=value
3182         else:
3183             self.__field_cmd=UINT(value,**{'sizeinbytes': 1,  'constant': 0x26 })
3184 
3185     def __delfield_cmd(self): del self.__field_cmd
3186 
3187     cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None)
3188 
3189     def __getfield_field(self):
3190         return self.__field_field.getvalue()
3191 
3192     def __setfield_field(self, value):
3193         if isinstance(value,UINT):
3194             self.__field_field=value
3195         else:
3196             self.__field_field=UINT(value,**{'sizeinbytes': 2})
3197 
3198     def __delfield_field(self): del self.__field_field
3199 
3200     field=property(__getfield_field, __setfield_field, __delfield_field, None)
3201 
3202     def __getfield_data(self):
3203         return self.__field_data.getvalue()
3204 
3205     def __setfield_data(self, value):
3206         if isinstance(value,DATA):
3207             self.__field_data=value
3208         else:
3209             self.__field_data=DATA(value,**{'sizeinbytes': 130})
3210 
3211     def __delfield_data(self): del self.__field_data
3212 
3213     data=property(__getfield_data, __setfield_data, __delfield_data, None)
3214 
3215     def iscontainer(self):
3216         return True
3217 
3218     def containerelements(self):
3219         yield ('cmd', self.__field_cmd, None)
3220         yield ('field', self.__field_field, None)
3221         yield ('data', self.__field_data, None)
3222 
3223 
3224 
3225 
3226 class FWInfoReq(BaseProtogenClass):
3227     __fields=['cmd']
3228 
3229     def __init__(self, *args, **kwargs):
3230         dict={}
3231         # What was supplied to this function
3232         dict.update(kwargs)
3233         # Parent constructor
3234         super(FWInfoReq,self).__init__(**dict)
3235         if self.__class__ is FWInfoReq:
3236             self._update(args,dict)
3237 
3238 
3239     def getfields(self):
3240         return self.__fields
3241 
3242 
3243     def _update(self, args, kwargs):
3244         super(FWInfoReq,self)._update(args,kwargs)
3245         keys=kwargs.keys()
3246         for key in keys:
3247             if key in self.__fields:
3248                 setattr(self, key, kwargs[key])
3249                 del kwargs[key]
3250         # Were any unrecognized kwargs passed in?
3251         if __debug__:
3252             self._complainaboutunusedargs(FWInfoReq,kwargs)
3253         if len(args):
3254             dict2={'sizeinbytes': 1,  'constant': 0x00}
3255             dict2.update(kwargs)
3256             kwargs=dict2
3257             self.__field_cmd=UINT(*args,**dict2)
3258         # Make all P fields that haven't already been constructed
3259 
3260 
3261     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3262         'Writes this packet to the supplied buffer'
3263         self._bufferstartoffset=buf.getcurrentoffset()
3264         try: self.__field_cmd
3265         except:
3266             self.__field_cmd=UINT(**{'sizeinbytes': 1,  'constant': 0x00})
3267         self.__field_cmd.writetobuffer(buf)
3268         self._bufferendoffset=buf.getcurrentoffset()
3269         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3270 
3271 
3272     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3273         'Reads this packet from the supplied buffer'
3274         self._bufferstartoffset=buf.getcurrentoffset()
3275         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3276         self.__field_cmd=UINT(**{'sizeinbytes': 1,  'constant': 0x00})
3277         self.__field_cmd.readfrombuffer(buf)
3278         self._bufferendoffset=buf.getcurrentoffset()
3279 
3280 
3281     def __getfield_cmd(self):
3282         try: self.__field_cmd
3283         except:
3284             self.__field_cmd=UINT(**{'sizeinbytes': 1,  'constant': 0x00})
3285         return self.__field_cmd.getvalue()
3286 
3287     def __setfield_cmd(self, value):
3288         if isinstance(value,UINT):
3289             self.__field_cmd=value
3290         else:
3291             self.__field_cmd=UINT(value,**{'sizeinbytes': 1,  'constant': 0x00})
3292 
3293     def __delfield_cmd(self): del self.__field_cmd
3294 
3295     cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None)
3296 
3297     def iscontainer(self):
3298         return True
3299 
3300     def containerelements(self):
3301         yield ('cmd', self.__field_cmd, None)
3302 
3303 
3304 
3305 
3306 class FWInfoRes(BaseProtogenClass):
3307     __fields=['cmd', 'fw_data']
3308 
3309     def __init__(self, *args, **kwargs):
3310         dict={}
3311         # What was supplied to this function
3312         dict.update(kwargs)
3313         # Parent constructor
3314         super(FWInfoRes,self).__init__(**dict)
3315         if self.__class__ is FWInfoRes:
3316             self._update(args,dict)
3317 
3318 
3319     def getfields(self):
3320         return self.__fields
3321 
3322 
3323     def _update(self, args, kwargs):
3324         super(FWInfoRes,self)._update(args,kwargs)
3325         keys=kwargs.keys()
3326         for key in keys:
3327             if key in self.__fields:
3328                 setattr(self, key, kwargs[key])
3329                 del kwargs[key]
3330         # Were any unrecognized kwargs passed in?
3331         if __debug__:
3332             self._complainaboutunusedargs(FWInfoRes,kwargs)
3333         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3334         # Make all P fields that haven't already been constructed
3335 
3336 
3337     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3338         'Writes this packet to the supplied buffer'
3339         self._bufferstartoffset=buf.getcurrentoffset()
3340         self.__field_cmd.writetobuffer(buf)
3341         self.__field_fw_data.writetobuffer(buf)
3342         self._bufferendoffset=buf.getcurrentoffset()
3343         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3344 
3345 
3346     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3347         'Reads this packet from the supplied buffer'
3348         self._bufferstartoffset=buf.getcurrentoffset()
3349         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3350         self.__field_cmd=UINT(**{'sizeinbytes': 1,  'constant': 0x00})
3351         self.__field_cmd.readfrombuffer(buf)
3352         self.__field_fw_data=DATA(**{'sizeinbytes': 53})
3353         self.__field_fw_data.readfrombuffer(buf)
3354         self._bufferendoffset=buf.getcurrentoffset()
3355 
3356 
3357     def __getfield_cmd(self):
3358         return self.__field_cmd.getvalue()
3359 
3360     def __setfield_cmd(self, value):
3361         if isinstance(value,UINT):
3362             self.__field_cmd=value
3363         else:
3364             self.__field_cmd=UINT(value,**{'sizeinbytes': 1,  'constant': 0x00})
3365 
3366     def __delfield_cmd(self): del self.__field_cmd
3367 
3368     cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None)
3369 
3370     def __getfield_fw_data(self):
3371         return self.__field_fw_data.getvalue()
3372 
3373     def __setfield_fw_data(self, value):
3374         if isinstance(value,DATA):
3375             self.__field_fw_data=value
3376         else:
3377             self.__field_fw_data=DATA(value,**{'sizeinbytes': 53})
3378 
3379     def __delfield_fw_data(self): del self.__field_fw_data
3380 
3381     fw_data=property(__getfield_fw_data, __setfield_fw_data, __delfield_fw_data, None)
3382 
3383     def iscontainer(self):
3384         return True
3385 
3386     def containerelements(self):
3387         yield ('cmd', self.__field_cmd, None)
3388         yield ('fw_data', self.__field_fw_data, None)
3389 
3390 
3391     def get_compile_time(self):
3392         _comptime = re.findall(r'(\d\d):(\d\d):(\d\d)', self.fw_data)[0]
3393         return int(_comptime[0]) * 100 + int (_comptime[1])
3394 
3395 
3396 
3397 
3398 
3399 class data(BaseProtogenClass):
3400     __fields=['bytes']
3401 
3402     def __init__(self, *args, **kwargs):
3403         dict={}
3404         # What was supplied to this function
3405         dict.update(kwargs)
3406         # Parent constructor
3407         super(data,self).__init__(**dict)
3408         if self.__class__ is data:
3409             self._update(args,dict)
3410 
3411 
3412     def getfields(self):
3413         return self.__fields
3414 
3415 
3416     def _update(self, args, kwargs):
3417         super(data,self)._update(args,kwargs)
3418         keys=kwargs.keys()
3419         for key in keys:
3420             if key in self.__fields:
3421                 setattr(self, key, kwargs[key])
3422                 del kwargs[key]
3423         # Were any unrecognized kwargs passed in?
3424         if __debug__:
3425             self._complainaboutunusedargs(data,kwargs)
3426         if len(args):
3427             dict2={}
3428             dict2.update(kwargs)
3429             kwargs=dict2
3430             self.__field_bytes=DATA(*args,**dict2)
3431         # Make all P fields that haven't already been constructed
3432 
3433 
3434     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3435         'Writes this packet to the supplied buffer'
3436         self._bufferstartoffset=buf.getcurrentoffset()
3437         self.__field_bytes.writetobuffer(buf)
3438         self._bufferendoffset=buf.getcurrentoffset()
3439         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3440 
3441 
3442     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3443         'Reads this packet from the supplied buffer'
3444         self._bufferstartoffset=buf.getcurrentoffset()
3445         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3446         self.__field_bytes=DATA()
3447         self.__field_bytes.readfrombuffer(buf)
3448         self._bufferendoffset=buf.getcurrentoffset()
3449 
3450 
3451     def __getfield_bytes(self):
3452         return self.__field_bytes.getvalue()
3453 
3454     def __setfield_bytes(self, value):
3455         if isinstance(value,DATA):
3456             self.__field_bytes=value
3457         else:
3458             self.__field_bytes=DATA(value,)
3459 
3460     def __delfield_bytes(self): del self.__field_bytes
3461 
3462     bytes=property(__getfield_bytes, __setfield_bytes, __delfield_bytes, None)
3463 
3464     def iscontainer(self):
3465         return True
3466 
3467     def containerelements(self):
3468         yield ('bytes', self.__field_bytes, None)
3469 
3470 
3471 
3472 
3473